1#[derive(prost_helpers::AnyPB)]
3#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4pub struct WaitVersion {
5 #[prost(uint64, tag = "1")]
6 pub catalog_version: u64,
7 #[prost(uint64, tag = "2")]
8 pub hummock_version_id: u64,
9}
10#[derive(prost_helpers::AnyPB)]
11#[derive(Clone, PartialEq, ::prost::Message)]
12pub struct CreateDatabaseRequest {
13 #[prost(message, optional, tag = "1")]
14 pub db: ::core::option::Option<super::catalog::Database>,
15}
16#[derive(prost_helpers::AnyPB)]
17#[derive(Clone, PartialEq, ::prost::Message)]
18pub struct CreateDatabaseResponse {
19 #[prost(message, optional, tag = "1")]
20 pub status: ::core::option::Option<super::common::Status>,
21 #[prost(message, optional, tag = "2")]
22 pub version: ::core::option::Option<WaitVersion>,
23}
24#[derive(prost_helpers::AnyPB)]
25#[derive(Clone, Copy, PartialEq, ::prost::Message)]
26pub struct DropDatabaseRequest {
27 #[prost(uint32, tag = "1")]
28 pub database_id: u32,
29}
30#[derive(prost_helpers::AnyPB)]
31#[derive(Clone, PartialEq, ::prost::Message)]
32pub struct DropDatabaseResponse {
33 #[prost(message, optional, tag = "1")]
34 pub status: ::core::option::Option<super::common::Status>,
35 #[prost(message, optional, tag = "2")]
36 pub version: ::core::option::Option<WaitVersion>,
37}
38#[derive(prost_helpers::AnyPB)]
39#[derive(Clone, PartialEq, ::prost::Message)]
40pub struct CreateSchemaRequest {
41 #[prost(message, optional, tag = "1")]
42 pub schema: ::core::option::Option<super::catalog::Schema>,
43}
44#[derive(prost_helpers::AnyPB)]
45#[derive(Clone, PartialEq, ::prost::Message)]
46pub struct CreateSchemaResponse {
47 #[prost(message, optional, tag = "1")]
48 pub status: ::core::option::Option<super::common::Status>,
49 #[prost(message, optional, tag = "2")]
50 pub version: ::core::option::Option<WaitVersion>,
51}
52#[derive(prost_helpers::AnyPB)]
53#[derive(Clone, Copy, PartialEq, ::prost::Message)]
54pub struct DropSchemaRequest {
55 #[prost(uint32, tag = "1")]
56 pub schema_id: u32,
57 #[prost(bool, tag = "2")]
58 pub cascade: bool,
59}
60#[derive(prost_helpers::AnyPB)]
61#[derive(Clone, PartialEq, ::prost::Message)]
62pub struct DropSchemaResponse {
63 #[prost(message, optional, tag = "1")]
64 pub status: ::core::option::Option<super::common::Status>,
65 #[prost(message, optional, tag = "2")]
66 pub version: ::core::option::Option<WaitVersion>,
67}
68#[derive(prost_helpers::AnyPB)]
69#[derive(Clone, PartialEq, ::prost::Message)]
70pub struct CreateSourceRequest {
71 #[prost(message, optional, tag = "1")]
72 pub source: ::core::option::Option<super::catalog::Source>,
73 #[prost(message, optional, tag = "2")]
74 pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
75 #[prost(bool, tag = "3")]
76 pub if_not_exists: bool,
77}
78#[derive(prost_helpers::AnyPB)]
79#[derive(Clone, PartialEq, ::prost::Message)]
80pub struct CreateSourceResponse {
81 #[prost(message, optional, tag = "1")]
82 pub status: ::core::option::Option<super::common::Status>,
83 #[prost(message, optional, tag = "2")]
84 pub version: ::core::option::Option<WaitVersion>,
85}
86#[derive(prost_helpers::AnyPB)]
87#[derive(Clone, Copy, PartialEq, ::prost::Message)]
88pub struct DropSourceRequest {
89 #[prost(uint32, tag = "1")]
90 pub source_id: u32,
91 #[prost(bool, tag = "2")]
92 pub cascade: bool,
93}
94#[derive(prost_helpers::AnyPB)]
95#[derive(Clone, PartialEq, ::prost::Message)]
96pub struct DropSourceResponse {
97 #[prost(message, optional, tag = "1")]
98 pub status: ::core::option::Option<super::common::Status>,
99 #[prost(message, optional, tag = "2")]
100 pub version: ::core::option::Option<WaitVersion>,
101}
102#[derive(prost_helpers::AnyPB)]
104#[derive(Clone, PartialEq, ::prost::Message)]
105pub struct AlterSourceRequest {
106 #[prost(message, optional, tag = "1")]
107 pub source: ::core::option::Option<super::catalog::Source>,
108}
109#[derive(prost_helpers::AnyPB)]
111#[derive(Clone, PartialEq, ::prost::Message)]
112pub struct AlterSourceResponse {
113 #[prost(message, optional, tag = "1")]
114 pub status: ::core::option::Option<super::common::Status>,
115 #[prost(message, optional, tag = "2")]
116 pub version: ::core::option::Option<WaitVersion>,
117}
118#[derive(prost_helpers::AnyPB)]
119#[derive(Clone, PartialEq, ::prost::Message)]
120pub struct CreateSinkRequest {
121 #[prost(message, optional, tag = "1")]
122 pub sink: ::core::option::Option<super::catalog::Sink>,
123 #[prost(message, optional, tag = "2")]
124 pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
125 #[prost(message, optional, tag = "3")]
127 pub affected_table_change: ::core::option::Option<ReplaceJobPlan>,
128 #[prost(uint32, repeated, tag = "4")]
130 pub dependencies: ::prost::alloc::vec::Vec<u32>,
131 #[prost(bool, tag = "5")]
132 pub if_not_exists: bool,
133}
134#[derive(prost_helpers::AnyPB)]
135#[derive(Clone, PartialEq, ::prost::Message)]
136pub struct CreateSinkResponse {
137 #[prost(message, optional, tag = "1")]
138 pub status: ::core::option::Option<super::common::Status>,
139 #[prost(message, optional, tag = "2")]
140 pub version: ::core::option::Option<WaitVersion>,
141}
142#[derive(prost_helpers::AnyPB)]
143#[derive(Clone, PartialEq, ::prost::Message)]
144pub struct DropSinkRequest {
145 #[prost(uint32, tag = "1")]
146 pub sink_id: u32,
147 #[prost(bool, tag = "2")]
148 pub cascade: bool,
149 #[prost(message, optional, tag = "3")]
150 pub affected_table_change: ::core::option::Option<ReplaceJobPlan>,
151}
152#[derive(prost_helpers::AnyPB)]
153#[derive(Clone, PartialEq, ::prost::Message)]
154pub struct DropSinkResponse {
155 #[prost(message, optional, tag = "1")]
156 pub status: ::core::option::Option<super::common::Status>,
157 #[prost(message, optional, tag = "2")]
158 pub version: ::core::option::Option<WaitVersion>,
159}
160#[derive(prost_helpers::AnyPB)]
161#[derive(Clone, PartialEq, ::prost::Message)]
162pub struct CreateSubscriptionRequest {
163 #[prost(message, optional, tag = "1")]
164 pub subscription: ::core::option::Option<super::catalog::Subscription>,
165}
166#[derive(prost_helpers::AnyPB)]
167#[derive(Clone, PartialEq, ::prost::Message)]
168pub struct CreateSubscriptionResponse {
169 #[prost(message, optional, tag = "1")]
170 pub status: ::core::option::Option<super::common::Status>,
171 #[prost(message, optional, tag = "2")]
172 pub version: ::core::option::Option<WaitVersion>,
173}
174#[derive(prost_helpers::AnyPB)]
175#[derive(Clone, Copy, PartialEq, ::prost::Message)]
176pub struct DropSubscriptionRequest {
177 #[prost(uint32, tag = "1")]
178 pub subscription_id: u32,
179 #[prost(bool, tag = "2")]
180 pub cascade: bool,
181}
182#[derive(prost_helpers::AnyPB)]
183#[derive(Clone, PartialEq, ::prost::Message)]
184pub struct DropSubscriptionResponse {
185 #[prost(message, optional, tag = "1")]
186 pub status: ::core::option::Option<super::common::Status>,
187 #[prost(message, optional, tag = "2")]
188 pub version: ::core::option::Option<WaitVersion>,
189}
190#[derive(prost_helpers::AnyPB)]
191#[derive(Clone, PartialEq, ::prost::Message)]
192pub struct CreateMaterializedViewRequest {
193 #[prost(message, optional, tag = "1")]
194 pub materialized_view: ::core::option::Option<super::catalog::Table>,
195 #[prost(message, optional, tag = "2")]
196 pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
197 #[prost(enumeration = "create_materialized_view_request::BackfillType", tag = "3")]
198 pub backfill: i32,
199 #[prost(uint32, repeated, tag = "4")]
201 pub dependencies: ::prost::alloc::vec::Vec<u32>,
202 #[prost(string, optional, tag = "5")]
204 pub specific_resource_group: ::core::option::Option<::prost::alloc::string::String>,
205 #[prost(bool, tag = "6")]
206 pub if_not_exists: bool,
207}
208pub mod create_materialized_view_request {
210 #[derive(prost_helpers::AnyPB)]
214 #[derive(
215 Clone,
216 Copy,
217 Debug,
218 PartialEq,
219 Eq,
220 Hash,
221 PartialOrd,
222 Ord,
223 ::prost::Enumeration
224 )]
225 #[repr(i32)]
226 pub enum BackfillType {
227 Unspecified = 0,
228 Regular = 1,
229 Serverless = 2,
230 }
231 impl BackfillType {
232 pub fn as_str_name(&self) -> &'static str {
237 match self {
238 Self::Unspecified => "UNSPECIFIED",
239 Self::Regular => "REGULAR",
240 Self::Serverless => "SERVERLESS",
241 }
242 }
243 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
245 match value {
246 "UNSPECIFIED" => Some(Self::Unspecified),
247 "REGULAR" => Some(Self::Regular),
248 "SERVERLESS" => Some(Self::Serverless),
249 _ => None,
250 }
251 }
252 }
253}
254#[derive(prost_helpers::AnyPB)]
255#[derive(Clone, PartialEq, ::prost::Message)]
256pub struct CreateMaterializedViewResponse {
257 #[prost(message, optional, tag = "1")]
258 pub status: ::core::option::Option<super::common::Status>,
259 #[prost(message, optional, tag = "2")]
260 pub version: ::core::option::Option<WaitVersion>,
261}
262#[derive(prost_helpers::AnyPB)]
263#[derive(Clone, Copy, PartialEq, ::prost::Message)]
264pub struct DropMaterializedViewRequest {
265 #[prost(uint32, tag = "1")]
266 pub table_id: u32,
267 #[prost(bool, tag = "2")]
268 pub cascade: bool,
269}
270#[derive(prost_helpers::AnyPB)]
271#[derive(Clone, PartialEq, ::prost::Message)]
272pub struct DropMaterializedViewResponse {
273 #[prost(message, optional, tag = "1")]
274 pub status: ::core::option::Option<super::common::Status>,
275 #[prost(message, optional, tag = "2")]
276 pub version: ::core::option::Option<WaitVersion>,
277}
278#[derive(prost_helpers::AnyPB)]
279#[derive(Clone, PartialEq, ::prost::Message)]
280pub struct CreateViewRequest {
281 #[prost(message, optional, tag = "1")]
282 pub view: ::core::option::Option<super::catalog::View>,
283}
284#[derive(prost_helpers::AnyPB)]
285#[derive(Clone, PartialEq, ::prost::Message)]
286pub struct CreateViewResponse {
287 #[prost(message, optional, tag = "1")]
288 pub status: ::core::option::Option<super::common::Status>,
289 #[prost(message, optional, tag = "2")]
290 pub version: ::core::option::Option<WaitVersion>,
291}
292#[derive(prost_helpers::AnyPB)]
293#[derive(Clone, Copy, PartialEq, ::prost::Message)]
294pub struct DropViewRequest {
295 #[prost(uint32, tag = "1")]
296 pub view_id: u32,
297 #[prost(bool, tag = "2")]
298 pub cascade: bool,
299}
300#[derive(prost_helpers::AnyPB)]
301#[derive(Clone, PartialEq, ::prost::Message)]
302pub struct DropViewResponse {
303 #[prost(message, optional, tag = "1")]
304 pub status: ::core::option::Option<super::common::Status>,
305 #[prost(message, optional, tag = "2")]
306 pub version: ::core::option::Option<WaitVersion>,
307}
308#[derive(prost_helpers::AnyPB)]
309#[derive(Clone, PartialEq, ::prost::Message)]
310pub struct CreateTableRequest {
311 #[prost(message, optional, tag = "1")]
314 pub source: ::core::option::Option<super::catalog::Source>,
315 #[prost(message, optional, tag = "2")]
316 pub materialized_view: ::core::option::Option<super::catalog::Table>,
317 #[prost(message, optional, tag = "3")]
318 pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
319 #[prost(enumeration = "TableJobType", tag = "4")]
320 pub job_type: i32,
321 #[prost(bool, tag = "5")]
322 pub if_not_exists: bool,
323}
324#[derive(prost_helpers::AnyPB)]
325#[derive(Clone, PartialEq, ::prost::Message)]
326pub struct CreateTableResponse {
327 #[prost(message, optional, tag = "1")]
328 pub status: ::core::option::Option<super::common::Status>,
329 #[prost(message, optional, tag = "2")]
330 pub version: ::core::option::Option<WaitVersion>,
331}
332#[derive(prost_helpers::AnyPB)]
333#[derive(Clone, PartialEq, ::prost::Message)]
334pub struct AlterNameRequest {
335 #[prost(string, tag = "20")]
336 pub new_name: ::prost::alloc::string::String,
337 #[prost(oneof = "alter_name_request::Object", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
338 pub object: ::core::option::Option<alter_name_request::Object>,
339}
340pub mod alter_name_request {
342 #[derive(prost_helpers::AnyPB)]
343 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
344 pub enum Object {
345 #[prost(uint32, tag = "1")]
346 TableId(u32),
347 #[prost(uint32, tag = "2")]
348 ViewId(u32),
349 #[prost(uint32, tag = "3")]
350 IndexId(u32),
351 #[prost(uint32, tag = "4")]
352 SinkId(u32),
353 #[prost(uint32, tag = "5")]
354 SourceId(u32),
355 #[prost(uint32, tag = "6")]
356 SchemaId(u32),
357 #[prost(uint32, tag = "7")]
358 DatabaseId(u32),
359 #[prost(uint32, tag = "8")]
360 SubscriptionId(u32),
361 }
362}
363#[derive(prost_helpers::AnyPB)]
364#[derive(Clone, PartialEq, ::prost::Message)]
365pub struct AlterNameResponse {
366 #[prost(message, optional, tag = "1")]
367 pub status: ::core::option::Option<super::common::Status>,
368 #[prost(message, optional, tag = "2")]
369 pub version: ::core::option::Option<WaitVersion>,
370}
371#[derive(prost_helpers::AnyPB)]
372#[derive(Clone, Copy, PartialEq, ::prost::Message)]
373pub struct AlterOwnerRequest {
374 #[prost(uint32, tag = "20")]
375 pub owner_id: u32,
376 #[prost(oneof = "alter_owner_request::Object", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
377 pub object: ::core::option::Option<alter_owner_request::Object>,
378}
379pub mod alter_owner_request {
381 #[derive(prost_helpers::AnyPB)]
382 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
383 pub enum Object {
384 #[prost(uint32, tag = "1")]
385 TableId(u32),
386 #[prost(uint32, tag = "2")]
387 ViewId(u32),
388 #[prost(uint32, tag = "3")]
389 SourceId(u32),
390 #[prost(uint32, tag = "4")]
391 SinkId(u32),
392 #[prost(uint32, tag = "5")]
393 SchemaId(u32),
394 #[prost(uint32, tag = "6")]
395 DatabaseId(u32),
396 #[prost(uint32, tag = "7")]
397 SubscriptionId(u32),
398 #[prost(uint32, tag = "8")]
399 ConnectionId(u32),
400 }
401}
402#[derive(prost_helpers::AnyPB)]
403#[derive(Clone, Copy, PartialEq, ::prost::Message)]
404pub struct AlterSetSchemaRequest {
405 #[prost(uint32, tag = "20")]
406 pub new_schema_id: u32,
407 #[prost(oneof = "alter_set_schema_request::Object", tags = "1, 2, 3, 4, 5, 6, 7")]
408 pub object: ::core::option::Option<alter_set_schema_request::Object>,
409}
410pub mod alter_set_schema_request {
412 #[derive(prost_helpers::AnyPB)]
413 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
414 pub enum Object {
415 #[prost(uint32, tag = "1")]
416 TableId(u32),
417 #[prost(uint32, tag = "2")]
418 ViewId(u32),
419 #[prost(uint32, tag = "3")]
420 SourceId(u32),
421 #[prost(uint32, tag = "4")]
422 SinkId(u32),
423 #[prost(uint32, tag = "5")]
424 FunctionId(u32),
425 #[prost(uint32, tag = "6")]
426 ConnectionId(u32),
427 #[prost(uint32, tag = "7")]
428 SubscriptionId(u32),
429 }
430}
431#[derive(prost_helpers::AnyPB)]
432#[derive(Clone, PartialEq, ::prost::Message)]
433pub struct AlterSetSchemaResponse {
434 #[prost(message, optional, tag = "1")]
435 pub status: ::core::option::Option<super::common::Status>,
436 #[prost(message, optional, tag = "2")]
437 pub version: ::core::option::Option<WaitVersion>,
438}
439#[derive(prost_helpers::AnyPB)]
440#[derive(Clone, Copy, PartialEq, ::prost::Message)]
441pub struct AlterParallelismRequest {
442 #[prost(uint32, tag = "1")]
444 pub table_id: u32,
445 #[prost(message, optional, tag = "2")]
446 pub parallelism: ::core::option::Option<super::meta::TableParallelism>,
447 #[prost(bool, tag = "3")]
448 pub deferred: bool,
449}
450#[derive(prost_helpers::AnyPB)]
451#[derive(Clone, Copy, PartialEq, ::prost::Message)]
452pub struct AlterParallelismResponse {}
453#[derive(prost_helpers::AnyPB)]
454#[derive(Clone, PartialEq, ::prost::Message)]
455pub struct AlterResourceGroupRequest {
456 #[prost(uint32, tag = "1")]
457 pub table_id: u32,
458 #[prost(string, optional, tag = "2")]
459 pub resource_group: ::core::option::Option<::prost::alloc::string::String>,
460 #[prost(bool, tag = "3")]
461 pub deferred: bool,
462}
463#[derive(prost_helpers::AnyPB)]
464#[derive(Clone, Copy, PartialEq, ::prost::Message)]
465pub struct AlterResourceGroupResponse {}
466#[derive(prost_helpers::AnyPB)]
467#[derive(Clone, PartialEq, ::prost::Message)]
468pub struct AlterOwnerResponse {
469 #[prost(message, optional, tag = "1")]
470 pub status: ::core::option::Option<super::common::Status>,
471 #[prost(message, optional, tag = "2")]
472 pub version: ::core::option::Option<WaitVersion>,
473}
474#[derive(prost_helpers::AnyPB)]
475#[derive(Clone, Copy, PartialEq, ::prost::Message)]
476pub struct AlterSwapRenameRequest {
477 #[prost(oneof = "alter_swap_rename_request::Object", tags = "1, 2, 3, 4, 5, 6")]
478 pub object: ::core::option::Option<alter_swap_rename_request::Object>,
479}
480pub mod alter_swap_rename_request {
482 #[derive(prost_helpers::AnyPB)]
483 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
484 pub struct ObjectNameSwapPair {
485 #[prost(uint32, tag = "1")]
486 pub src_object_id: u32,
487 #[prost(uint32, tag = "2")]
488 pub dst_object_id: u32,
489 }
490 #[derive(prost_helpers::AnyPB)]
491 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
492 pub enum Object {
493 #[prost(message, tag = "1")]
494 Schema(ObjectNameSwapPair),
495 #[prost(message, tag = "2")]
496 Table(ObjectNameSwapPair),
497 #[prost(message, tag = "3")]
498 View(ObjectNameSwapPair),
499 #[prost(message, tag = "4")]
500 Source(ObjectNameSwapPair),
501 #[prost(message, tag = "5")]
502 Sink(ObjectNameSwapPair),
503 #[prost(message, tag = "6")]
504 Subscription(ObjectNameSwapPair),
505 }
506}
507#[derive(prost_helpers::AnyPB)]
508#[derive(Clone, PartialEq, ::prost::Message)]
509pub struct AlterSwapRenameResponse {
510 #[prost(message, optional, tag = "1")]
511 pub status: ::core::option::Option<super::common::Status>,
512 #[prost(message, optional, tag = "2")]
513 pub version: ::core::option::Option<WaitVersion>,
514}
515#[derive(prost_helpers::AnyPB)]
516#[derive(Clone, PartialEq, ::prost::Message)]
517pub struct CreateFunctionRequest {
518 #[prost(message, optional, tag = "1")]
519 pub function: ::core::option::Option<super::catalog::Function>,
520}
521#[derive(prost_helpers::AnyPB)]
522#[derive(Clone, PartialEq, ::prost::Message)]
523pub struct CreateFunctionResponse {
524 #[prost(message, optional, tag = "1")]
525 pub status: ::core::option::Option<super::common::Status>,
526 #[prost(message, optional, tag = "2")]
527 pub version: ::core::option::Option<WaitVersion>,
528}
529#[derive(prost_helpers::AnyPB)]
530#[derive(Clone, Copy, PartialEq, ::prost::Message)]
531pub struct DropFunctionRequest {
532 #[prost(uint32, tag = "1")]
533 pub function_id: u32,
534}
535#[derive(prost_helpers::AnyPB)]
536#[derive(Clone, PartialEq, ::prost::Message)]
537pub struct DropFunctionResponse {
538 #[prost(message, optional, tag = "1")]
539 pub status: ::core::option::Option<super::common::Status>,
540 #[prost(message, optional, tag = "2")]
541 pub version: ::core::option::Option<WaitVersion>,
542}
543#[derive(prost_helpers::AnyPB)]
544#[derive(Clone, Copy, PartialEq, ::prost::Message)]
545pub struct DropTableRequest {
546 #[prost(uint32, tag = "2")]
547 pub table_id: u32,
548 #[prost(bool, tag = "3")]
549 pub cascade: bool,
550 #[prost(oneof = "drop_table_request::SourceId", tags = "1")]
551 pub source_id: ::core::option::Option<drop_table_request::SourceId>,
552}
553pub mod drop_table_request {
555 #[derive(prost_helpers::AnyPB)]
556 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
557 pub enum SourceId {
558 #[prost(uint32, tag = "1")]
559 Id(u32),
560 }
561}
562#[derive(prost_helpers::AnyPB)]
563#[derive(Clone, PartialEq, ::prost::Message)]
564pub struct DropTableResponse {
565 #[prost(message, optional, tag = "1")]
566 pub status: ::core::option::Option<super::common::Status>,
567 #[prost(message, optional, tag = "2")]
568 pub version: ::core::option::Option<WaitVersion>,
569}
570#[derive(prost_helpers::AnyPB)]
572#[derive(Clone, Copy, PartialEq, ::prost::Message)]
573pub struct RisectlListStateTablesRequest {}
574#[derive(prost_helpers::AnyPB)]
576#[derive(Clone, PartialEq, ::prost::Message)]
577pub struct RisectlListStateTablesResponse {
578 #[prost(message, repeated, tag = "1")]
579 pub tables: ::prost::alloc::vec::Vec<super::catalog::Table>,
580}
581#[derive(prost_helpers::AnyPB)]
582#[derive(Clone, PartialEq, ::prost::Message)]
583pub struct CreateIndexRequest {
584 #[prost(message, optional, tag = "1")]
585 pub index: ::core::option::Option<super::catalog::Index>,
586 #[prost(message, optional, tag = "2")]
587 pub index_table: ::core::option::Option<super::catalog::Table>,
588 #[prost(message, optional, tag = "3")]
589 pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
590 #[prost(bool, tag = "4")]
591 pub if_not_exists: bool,
592}
593#[derive(prost_helpers::AnyPB)]
594#[derive(Clone, PartialEq, ::prost::Message)]
595pub struct CreateIndexResponse {
596 #[prost(message, optional, tag = "1")]
597 pub status: ::core::option::Option<super::common::Status>,
598 #[prost(message, optional, tag = "2")]
599 pub version: ::core::option::Option<WaitVersion>,
600}
601#[derive(prost_helpers::AnyPB)]
602#[derive(Clone, Copy, PartialEq, ::prost::Message)]
603pub struct DropIndexRequest {
604 #[prost(uint32, tag = "1")]
605 pub index_id: u32,
606 #[prost(bool, tag = "2")]
607 pub cascade: bool,
608}
609#[derive(prost_helpers::AnyPB)]
610#[derive(Clone, PartialEq, ::prost::Message)]
611pub struct DropIndexResponse {
612 #[prost(message, optional, tag = "1")]
613 pub status: ::core::option::Option<super::common::Status>,
614 #[prost(message, optional, tag = "2")]
615 pub version: ::core::option::Option<WaitVersion>,
616}
617#[derive(prost_helpers::AnyPB)]
618#[derive(Clone, PartialEq, ::prost::Message)]
619pub struct ReplaceJobPlan {
620 #[prost(message, optional, tag = "1")]
622 pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
623 #[prost(oneof = "replace_job_plan::ReplaceJob", tags = "3, 4")]
624 pub replace_job: ::core::option::Option<replace_job_plan::ReplaceJob>,
625}
626pub mod replace_job_plan {
628 #[derive(prost_helpers::AnyPB)]
629 #[derive(Clone, PartialEq, ::prost::Message)]
630 pub struct ReplaceTable {
631 #[prost(message, optional, tag = "1")]
635 pub table: ::core::option::Option<super::super::catalog::Table>,
636 #[prost(message, optional, tag = "2")]
638 pub source: ::core::option::Option<super::super::catalog::Source>,
639 #[prost(enumeration = "super::TableJobType", tag = "3")]
640 pub job_type: i32,
641 }
642 #[derive(prost_helpers::AnyPB)]
643 #[derive(Clone, PartialEq, ::prost::Message)]
644 pub struct ReplaceSource {
645 #[prost(message, optional, tag = "1")]
646 pub source: ::core::option::Option<super::super::catalog::Source>,
647 }
648 #[derive(prost_helpers::AnyPB)]
649 #[derive(Clone, PartialEq, ::prost::Oneof)]
650 pub enum ReplaceJob {
651 #[prost(message, tag = "3")]
652 ReplaceTable(ReplaceTable),
653 #[prost(message, tag = "4")]
654 ReplaceSource(ReplaceSource),
655 }
656}
657#[derive(prost_helpers::AnyPB)]
658#[derive(Clone, PartialEq, ::prost::Message)]
659pub struct ReplaceJobPlanRequest {
660 #[prost(message, optional, tag = "1")]
661 pub plan: ::core::option::Option<ReplaceJobPlan>,
662}
663#[derive(prost_helpers::AnyPB)]
664#[derive(Clone, PartialEq, ::prost::Message)]
665pub struct ReplaceJobPlanResponse {
666 #[prost(message, optional, tag = "1")]
667 pub status: ::core::option::Option<super::common::Status>,
668 #[prost(message, optional, tag = "2")]
670 pub version: ::core::option::Option<WaitVersion>,
671}
672#[derive(prost_helpers::AnyPB)]
673#[derive(Clone, PartialEq, ::prost::Message)]
674pub struct GetTableRequest {
675 #[prost(string, tag = "1")]
676 pub database_name: ::prost::alloc::string::String,
677 #[prost(string, tag = "2")]
678 pub table_name: ::prost::alloc::string::String,
679}
680#[derive(prost_helpers::AnyPB)]
681#[derive(Clone, PartialEq, ::prost::Message)]
682pub struct GetTableResponse {
683 #[prost(message, optional, tag = "1")]
684 pub table: ::core::option::Option<super::catalog::Table>,
685}
686#[derive(prost_helpers::AnyPB)]
687#[derive(Clone, Copy, PartialEq, ::prost::Message)]
688pub struct GetDdlProgressRequest {}
689#[derive(prost_helpers::AnyPB)]
690#[derive(Clone, PartialEq, ::prost::Message)]
691pub struct DdlProgress {
692 #[prost(uint64, tag = "1")]
693 pub id: u64,
694 #[prost(string, tag = "2")]
695 pub statement: ::prost::alloc::string::String,
696 #[prost(string, tag = "3")]
697 pub progress: ::prost::alloc::string::String,
698}
699#[derive(prost_helpers::AnyPB)]
700#[derive(Clone, PartialEq, ::prost::Message)]
701pub struct GetDdlProgressResponse {
702 #[prost(message, repeated, tag = "1")]
703 pub ddl_progress: ::prost::alloc::vec::Vec<DdlProgress>,
704}
705#[derive(prost_helpers::AnyPB)]
706#[derive(Clone, PartialEq, ::prost::Message)]
707pub struct CreateSecretRequest {
708 #[prost(string, tag = "1")]
709 pub name: ::prost::alloc::string::String,
710 #[prost(bytes = "vec", tag = "2")]
711 pub value: ::prost::alloc::vec::Vec<u8>,
712 #[prost(uint32, tag = "3")]
713 pub database_id: u32,
714 #[prost(uint32, tag = "4")]
715 pub schema_id: u32,
716 #[prost(uint32, tag = "5")]
717 pub owner_id: u32,
718}
719#[derive(prost_helpers::AnyPB)]
720#[derive(Clone, Copy, PartialEq, ::prost::Message)]
721pub struct CreateSecretResponse {
722 #[prost(message, optional, tag = "1")]
723 pub version: ::core::option::Option<WaitVersion>,
724}
725#[derive(prost_helpers::AnyPB)]
726#[derive(Clone, Copy, PartialEq, ::prost::Message)]
727pub struct DropSecretRequest {
728 #[prost(uint32, tag = "1")]
729 pub secret_id: u32,
730}
731#[derive(prost_helpers::AnyPB)]
732#[derive(Clone, Copy, PartialEq, ::prost::Message)]
733pub struct DropSecretResponse {
734 #[prost(message, optional, tag = "1")]
735 pub version: ::core::option::Option<WaitVersion>,
736}
737#[derive(prost_helpers::AnyPB)]
738#[derive(Clone, PartialEq, ::prost::Message)]
739pub struct AlterSecretRequest {
740 #[prost(uint32, tag = "1")]
741 pub secret_id: u32,
742 #[prost(string, tag = "2")]
743 pub name: ::prost::alloc::string::String,
744 #[prost(bytes = "vec", tag = "3")]
745 pub value: ::prost::alloc::vec::Vec<u8>,
746 #[prost(uint32, tag = "4")]
747 pub database_id: u32,
748 #[prost(uint32, tag = "5")]
749 pub schema_id: u32,
750 #[prost(uint32, tag = "6")]
751 pub owner_id: u32,
752}
753#[derive(prost_helpers::AnyPB)]
754#[derive(Clone, Copy, PartialEq, ::prost::Message)]
755pub struct AlterSecretResponse {
756 #[prost(message, optional, tag = "1")]
757 pub version: ::core::option::Option<WaitVersion>,
758}
759#[derive(prost_helpers::AnyPB)]
760#[derive(Clone, PartialEq, ::prost::Message)]
761pub struct CreateConnectionRequest {
762 #[prost(string, tag = "1")]
763 pub name: ::prost::alloc::string::String,
764 #[prost(uint32, tag = "2")]
765 pub database_id: u32,
766 #[prost(uint32, tag = "3")]
767 pub schema_id: u32,
768 #[prost(uint32, tag = "5")]
769 pub owner_id: u32,
770 #[prost(oneof = "create_connection_request::Payload", tags = "4, 6")]
771 pub payload: ::core::option::Option<create_connection_request::Payload>,
772}
773pub mod create_connection_request {
775 #[derive(prost_helpers::AnyPB)]
776 #[derive(Clone, PartialEq, ::prost::Message)]
777 pub struct PrivateLink {
778 #[prost(
779 enumeration = "super::super::catalog::connection::private_link_service::PrivateLinkProvider",
780 tag = "1"
781 )]
782 pub provider: i32,
783 #[prost(string, tag = "2")]
784 pub service_name: ::prost::alloc::string::String,
785 #[prost(string, optional, tag = "3")]
786 pub tags: ::core::option::Option<::prost::alloc::string::String>,
787 }
788 #[derive(prost_helpers::AnyPB)]
789 #[derive(Clone, PartialEq, ::prost::Oneof)]
790 pub enum Payload {
791 #[prost(message, tag = "4")]
792 PrivateLink(PrivateLink),
793 #[prost(message, tag = "6")]
794 ConnectionParams(super::super::catalog::ConnectionParams),
795 }
796}
797#[derive(prost_helpers::AnyPB)]
798#[derive(Clone, Copy, PartialEq, ::prost::Message)]
799pub struct CreateConnectionResponse {
800 #[prost(message, optional, tag = "1")]
802 pub version: ::core::option::Option<WaitVersion>,
803}
804#[derive(prost_helpers::AnyPB)]
805#[derive(Clone, Copy, PartialEq, ::prost::Message)]
806pub struct ListConnectionsRequest {}
807#[derive(prost_helpers::AnyPB)]
808#[derive(Clone, PartialEq, ::prost::Message)]
809pub struct ListConnectionsResponse {
810 #[prost(message, repeated, tag = "1")]
811 pub connections: ::prost::alloc::vec::Vec<super::catalog::Connection>,
812}
813#[derive(prost_helpers::AnyPB)]
814#[derive(Clone, Copy, PartialEq, ::prost::Message)]
815pub struct DropConnectionRequest {
816 #[prost(uint32, tag = "1")]
817 pub connection_id: u32,
818}
819#[derive(prost_helpers::AnyPB)]
820#[derive(Clone, PartialEq, ::prost::Message)]
821pub struct DropConnectionResponse {
822 #[prost(message, optional, tag = "1")]
823 pub status: ::core::option::Option<super::common::Status>,
824 #[prost(message, optional, tag = "2")]
825 pub version: ::core::option::Option<WaitVersion>,
826}
827#[derive(prost_helpers::AnyPB)]
828#[derive(Clone, PartialEq, ::prost::Message)]
829pub struct GetTablesRequest {
830 #[prost(uint32, repeated, tag = "1")]
831 pub table_ids: ::prost::alloc::vec::Vec<u32>,
832 #[prost(bool, tag = "2")]
833 pub include_dropped_tables: bool,
834}
835#[derive(prost_helpers::AnyPB)]
836#[derive(Clone, PartialEq, ::prost::Message)]
837pub struct GetTablesResponse {
838 #[prost(map = "uint32, message", tag = "1")]
839 pub tables: ::std::collections::HashMap<u32, super::catalog::Table>,
840}
841#[derive(prost_helpers::AnyPB)]
842#[derive(Clone, Copy, PartialEq, ::prost::Message)]
843pub struct WaitRequest {}
844#[derive(prost_helpers::AnyPB)]
845#[derive(Clone, Copy, PartialEq, ::prost::Message)]
846pub struct WaitResponse {}
847#[derive(prost_helpers::AnyPB)]
848#[derive(Clone, PartialEq, ::prost::Message)]
849pub struct CommentOnRequest {
850 #[prost(message, optional, tag = "1")]
851 pub comment: ::core::option::Option<super::catalog::Comment>,
852}
853#[derive(prost_helpers::AnyPB)]
854#[derive(Clone, PartialEq, ::prost::Message)]
855pub struct CommentOnResponse {
856 #[prost(message, optional, tag = "1")]
857 pub status: ::core::option::Option<super::common::Status>,
858 #[prost(message, optional, tag = "2")]
859 pub version: ::core::option::Option<WaitVersion>,
860}
861#[derive(prost_helpers::AnyPB)]
862#[derive(Clone, PartialEq, ::prost::Message)]
863pub struct TableSchemaChange {
864 #[prost(enumeration = "table_schema_change::TableChangeType", tag = "1")]
865 pub change_type: i32,
866 #[prost(string, tag = "2")]
867 pub cdc_table_id: ::prost::alloc::string::String,
868 #[prost(message, repeated, tag = "3")]
869 pub columns: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
870 #[prost(string, tag = "4")]
871 pub upstream_ddl: ::prost::alloc::string::String,
872}
873pub mod table_schema_change {
875 #[derive(prost_helpers::AnyPB)]
876 #[derive(
877 Clone,
878 Copy,
879 Debug,
880 PartialEq,
881 Eq,
882 Hash,
883 PartialOrd,
884 Ord,
885 ::prost::Enumeration
886 )]
887 #[repr(i32)]
888 pub enum TableChangeType {
889 Unspecified = 0,
890 Alter = 1,
891 Create = 2,
892 Drop = 3,
893 }
894 impl TableChangeType {
895 pub fn as_str_name(&self) -> &'static str {
900 match self {
901 Self::Unspecified => "UNSPECIFIED",
902 Self::Alter => "ALTER",
903 Self::Create => "CREATE",
904 Self::Drop => "DROP",
905 }
906 }
907 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
909 match value {
910 "UNSPECIFIED" => Some(Self::Unspecified),
911 "ALTER" => Some(Self::Alter),
912 "CREATE" => Some(Self::Create),
913 "DROP" => Some(Self::Drop),
914 _ => None,
915 }
916 }
917 }
918}
919#[derive(prost_helpers::AnyPB)]
920#[derive(Clone, PartialEq, ::prost::Message)]
921pub struct SchemaChangeEnvelope {
922 #[prost(message, repeated, tag = "1")]
923 pub table_changes: ::prost::alloc::vec::Vec<TableSchemaChange>,
924}
925#[derive(prost_helpers::AnyPB)]
926#[derive(Clone, PartialEq, ::prost::Message)]
927pub struct AutoSchemaChangeRequest {
928 #[prost(message, optional, tag = "1")]
929 pub schema_change: ::core::option::Option<SchemaChangeEnvelope>,
930}
931#[derive(prost_helpers::AnyPB)]
932#[derive(Clone, Copy, PartialEq, ::prost::Message)]
933pub struct AutoSchemaChangeResponse {}
934#[derive(prost_helpers::AnyPB)]
935#[derive(Clone, Copy, PartialEq, ::prost::Message)]
936pub struct AlterDatabaseParamRequest {
937 #[prost(uint32, tag = "1")]
938 pub database_id: u32,
939 #[prost(oneof = "alter_database_param_request::Param", tags = "2, 3")]
940 pub param: ::core::option::Option<alter_database_param_request::Param>,
941}
942pub mod alter_database_param_request {
944 #[derive(prost_helpers::AnyPB)]
945 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
946 pub enum Param {
947 #[prost(message, tag = "2")]
948 BarrierIntervalMs(super::super::common::OptionalUint32),
949 #[prost(message, tag = "3")]
950 CheckpointFrequency(super::super::common::OptionalUint64),
951 }
952}
953#[derive(prost_helpers::AnyPB)]
954#[derive(Clone, PartialEq, ::prost::Message)]
955pub struct AlterDatabaseParamResponse {
956 #[prost(message, optional, tag = "1")]
957 pub status: ::core::option::Option<super::common::Status>,
958 #[prost(message, optional, tag = "2")]
959 pub version: ::core::option::Option<WaitVersion>,
960}
961#[derive(prost_helpers::AnyPB)]
973#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
974#[repr(i32)]
975pub enum TableJobType {
976 Unspecified = 0,
977 General = 1,
979 SharedCdcSource = 2,
981}
982impl TableJobType {
983 pub fn as_str_name(&self) -> &'static str {
988 match self {
989 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
990 Self::General => "TABLE_JOB_TYPE_GENERAL",
991 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
992 }
993 }
994 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
996 match value {
997 "TABLE_JOB_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
998 "TABLE_JOB_TYPE_GENERAL" => Some(Self::General),
999 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Some(Self::SharedCdcSource),
1000 _ => None,
1001 }
1002 }
1003}
1004pub mod ddl_service_client {
1006 #![allow(
1007 unused_variables,
1008 dead_code,
1009 missing_docs,
1010 clippy::wildcard_imports,
1011 clippy::let_unit_value,
1012 )]
1013 use tonic::codegen::*;
1014 use tonic::codegen::http::Uri;
1015 #[derive(Debug, Clone)]
1016 pub struct DdlServiceClient<T> {
1017 inner: tonic::client::Grpc<T>,
1018 }
1019 impl DdlServiceClient<tonic::transport::Channel> {
1020 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1022 where
1023 D: TryInto<tonic::transport::Endpoint>,
1024 D::Error: Into<StdError>,
1025 {
1026 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1027 Ok(Self::new(conn))
1028 }
1029 }
1030 impl<T> DdlServiceClient<T>
1031 where
1032 T: tonic::client::GrpcService<tonic::body::BoxBody>,
1033 T::Error: Into<StdError>,
1034 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
1035 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
1036 {
1037 pub fn new(inner: T) -> Self {
1038 let inner = tonic::client::Grpc::new(inner);
1039 Self { inner }
1040 }
1041 pub fn with_origin(inner: T, origin: Uri) -> Self {
1042 let inner = tonic::client::Grpc::with_origin(inner, origin);
1043 Self { inner }
1044 }
1045 pub fn with_interceptor<F>(
1046 inner: T,
1047 interceptor: F,
1048 ) -> DdlServiceClient<InterceptedService<T, F>>
1049 where
1050 F: tonic::service::Interceptor,
1051 T::ResponseBody: Default,
1052 T: tonic::codegen::Service<
1053 http::Request<tonic::body::BoxBody>,
1054 Response = http::Response<
1055 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1056 >,
1057 >,
1058 <T as tonic::codegen::Service<
1059 http::Request<tonic::body::BoxBody>,
1060 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1061 {
1062 DdlServiceClient::new(InterceptedService::new(inner, interceptor))
1063 }
1064 #[must_use]
1069 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1070 self.inner = self.inner.send_compressed(encoding);
1071 self
1072 }
1073 #[must_use]
1075 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1076 self.inner = self.inner.accept_compressed(encoding);
1077 self
1078 }
1079 #[must_use]
1083 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1084 self.inner = self.inner.max_decoding_message_size(limit);
1085 self
1086 }
1087 #[must_use]
1091 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1092 self.inner = self.inner.max_encoding_message_size(limit);
1093 self
1094 }
1095 pub async fn create_database(
1096 &mut self,
1097 request: impl tonic::IntoRequest<super::CreateDatabaseRequest>,
1098 ) -> std::result::Result<
1099 tonic::Response<super::CreateDatabaseResponse>,
1100 tonic::Status,
1101 > {
1102 self.inner
1103 .ready()
1104 .await
1105 .map_err(|e| {
1106 tonic::Status::unknown(
1107 format!("Service was not ready: {}", e.into()),
1108 )
1109 })?;
1110 let codec = tonic::codec::ProstCodec::default();
1111 let path = http::uri::PathAndQuery::from_static(
1112 "/ddl_service.DdlService/CreateDatabase",
1113 );
1114 let mut req = request.into_request();
1115 req.extensions_mut()
1116 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateDatabase"));
1117 self.inner.unary(req, path, codec).await
1118 }
1119 pub async fn drop_database(
1120 &mut self,
1121 request: impl tonic::IntoRequest<super::DropDatabaseRequest>,
1122 ) -> std::result::Result<
1123 tonic::Response<super::DropDatabaseResponse>,
1124 tonic::Status,
1125 > {
1126 self.inner
1127 .ready()
1128 .await
1129 .map_err(|e| {
1130 tonic::Status::unknown(
1131 format!("Service was not ready: {}", e.into()),
1132 )
1133 })?;
1134 let codec = tonic::codec::ProstCodec::default();
1135 let path = http::uri::PathAndQuery::from_static(
1136 "/ddl_service.DdlService/DropDatabase",
1137 );
1138 let mut req = request.into_request();
1139 req.extensions_mut()
1140 .insert(GrpcMethod::new("ddl_service.DdlService", "DropDatabase"));
1141 self.inner.unary(req, path, codec).await
1142 }
1143 pub async fn create_schema(
1144 &mut self,
1145 request: impl tonic::IntoRequest<super::CreateSchemaRequest>,
1146 ) -> std::result::Result<
1147 tonic::Response<super::CreateSchemaResponse>,
1148 tonic::Status,
1149 > {
1150 self.inner
1151 .ready()
1152 .await
1153 .map_err(|e| {
1154 tonic::Status::unknown(
1155 format!("Service was not ready: {}", e.into()),
1156 )
1157 })?;
1158 let codec = tonic::codec::ProstCodec::default();
1159 let path = http::uri::PathAndQuery::from_static(
1160 "/ddl_service.DdlService/CreateSchema",
1161 );
1162 let mut req = request.into_request();
1163 req.extensions_mut()
1164 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSchema"));
1165 self.inner.unary(req, path, codec).await
1166 }
1167 pub async fn drop_schema(
1168 &mut self,
1169 request: impl tonic::IntoRequest<super::DropSchemaRequest>,
1170 ) -> std::result::Result<
1171 tonic::Response<super::DropSchemaResponse>,
1172 tonic::Status,
1173 > {
1174 self.inner
1175 .ready()
1176 .await
1177 .map_err(|e| {
1178 tonic::Status::unknown(
1179 format!("Service was not ready: {}", e.into()),
1180 )
1181 })?;
1182 let codec = tonic::codec::ProstCodec::default();
1183 let path = http::uri::PathAndQuery::from_static(
1184 "/ddl_service.DdlService/DropSchema",
1185 );
1186 let mut req = request.into_request();
1187 req.extensions_mut()
1188 .insert(GrpcMethod::new("ddl_service.DdlService", "DropSchema"));
1189 self.inner.unary(req, path, codec).await
1190 }
1191 pub async fn create_source(
1192 &mut self,
1193 request: impl tonic::IntoRequest<super::CreateSourceRequest>,
1194 ) -> std::result::Result<
1195 tonic::Response<super::CreateSourceResponse>,
1196 tonic::Status,
1197 > {
1198 self.inner
1199 .ready()
1200 .await
1201 .map_err(|e| {
1202 tonic::Status::unknown(
1203 format!("Service was not ready: {}", e.into()),
1204 )
1205 })?;
1206 let codec = tonic::codec::ProstCodec::default();
1207 let path = http::uri::PathAndQuery::from_static(
1208 "/ddl_service.DdlService/CreateSource",
1209 );
1210 let mut req = request.into_request();
1211 req.extensions_mut()
1212 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSource"));
1213 self.inner.unary(req, path, codec).await
1214 }
1215 pub async fn drop_source(
1216 &mut self,
1217 request: impl tonic::IntoRequest<super::DropSourceRequest>,
1218 ) -> std::result::Result<
1219 tonic::Response<super::DropSourceResponse>,
1220 tonic::Status,
1221 > {
1222 self.inner
1223 .ready()
1224 .await
1225 .map_err(|e| {
1226 tonic::Status::unknown(
1227 format!("Service was not ready: {}", e.into()),
1228 )
1229 })?;
1230 let codec = tonic::codec::ProstCodec::default();
1231 let path = http::uri::PathAndQuery::from_static(
1232 "/ddl_service.DdlService/DropSource",
1233 );
1234 let mut req = request.into_request();
1235 req.extensions_mut()
1236 .insert(GrpcMethod::new("ddl_service.DdlService", "DropSource"));
1237 self.inner.unary(req, path, codec).await
1238 }
1239 pub async fn create_sink(
1240 &mut self,
1241 request: impl tonic::IntoRequest<super::CreateSinkRequest>,
1242 ) -> std::result::Result<
1243 tonic::Response<super::CreateSinkResponse>,
1244 tonic::Status,
1245 > {
1246 self.inner
1247 .ready()
1248 .await
1249 .map_err(|e| {
1250 tonic::Status::unknown(
1251 format!("Service was not ready: {}", e.into()),
1252 )
1253 })?;
1254 let codec = tonic::codec::ProstCodec::default();
1255 let path = http::uri::PathAndQuery::from_static(
1256 "/ddl_service.DdlService/CreateSink",
1257 );
1258 let mut req = request.into_request();
1259 req.extensions_mut()
1260 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSink"));
1261 self.inner.unary(req, path, codec).await
1262 }
1263 pub async fn create_subscription(
1264 &mut self,
1265 request: impl tonic::IntoRequest<super::CreateSubscriptionRequest>,
1266 ) -> std::result::Result<
1267 tonic::Response<super::CreateSubscriptionResponse>,
1268 tonic::Status,
1269 > {
1270 self.inner
1271 .ready()
1272 .await
1273 .map_err(|e| {
1274 tonic::Status::unknown(
1275 format!("Service was not ready: {}", e.into()),
1276 )
1277 })?;
1278 let codec = tonic::codec::ProstCodec::default();
1279 let path = http::uri::PathAndQuery::from_static(
1280 "/ddl_service.DdlService/CreateSubscription",
1281 );
1282 let mut req = request.into_request();
1283 req.extensions_mut()
1284 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSubscription"));
1285 self.inner.unary(req, path, codec).await
1286 }
1287 pub async fn drop_sink(
1288 &mut self,
1289 request: impl tonic::IntoRequest<super::DropSinkRequest>,
1290 ) -> std::result::Result<
1291 tonic::Response<super::DropSinkResponse>,
1292 tonic::Status,
1293 > {
1294 self.inner
1295 .ready()
1296 .await
1297 .map_err(|e| {
1298 tonic::Status::unknown(
1299 format!("Service was not ready: {}", e.into()),
1300 )
1301 })?;
1302 let codec = tonic::codec::ProstCodec::default();
1303 let path = http::uri::PathAndQuery::from_static(
1304 "/ddl_service.DdlService/DropSink",
1305 );
1306 let mut req = request.into_request();
1307 req.extensions_mut()
1308 .insert(GrpcMethod::new("ddl_service.DdlService", "DropSink"));
1309 self.inner.unary(req, path, codec).await
1310 }
1311 pub async fn drop_subscription(
1312 &mut self,
1313 request: impl tonic::IntoRequest<super::DropSubscriptionRequest>,
1314 ) -> std::result::Result<
1315 tonic::Response<super::DropSubscriptionResponse>,
1316 tonic::Status,
1317 > {
1318 self.inner
1319 .ready()
1320 .await
1321 .map_err(|e| {
1322 tonic::Status::unknown(
1323 format!("Service was not ready: {}", e.into()),
1324 )
1325 })?;
1326 let codec = tonic::codec::ProstCodec::default();
1327 let path = http::uri::PathAndQuery::from_static(
1328 "/ddl_service.DdlService/DropSubscription",
1329 );
1330 let mut req = request.into_request();
1331 req.extensions_mut()
1332 .insert(GrpcMethod::new("ddl_service.DdlService", "DropSubscription"));
1333 self.inner.unary(req, path, codec).await
1334 }
1335 pub async fn create_materialized_view(
1336 &mut self,
1337 request: impl tonic::IntoRequest<super::CreateMaterializedViewRequest>,
1338 ) -> std::result::Result<
1339 tonic::Response<super::CreateMaterializedViewResponse>,
1340 tonic::Status,
1341 > {
1342 self.inner
1343 .ready()
1344 .await
1345 .map_err(|e| {
1346 tonic::Status::unknown(
1347 format!("Service was not ready: {}", e.into()),
1348 )
1349 })?;
1350 let codec = tonic::codec::ProstCodec::default();
1351 let path = http::uri::PathAndQuery::from_static(
1352 "/ddl_service.DdlService/CreateMaterializedView",
1353 );
1354 let mut req = request.into_request();
1355 req.extensions_mut()
1356 .insert(
1357 GrpcMethod::new("ddl_service.DdlService", "CreateMaterializedView"),
1358 );
1359 self.inner.unary(req, path, codec).await
1360 }
1361 pub async fn drop_materialized_view(
1362 &mut self,
1363 request: impl tonic::IntoRequest<super::DropMaterializedViewRequest>,
1364 ) -> std::result::Result<
1365 tonic::Response<super::DropMaterializedViewResponse>,
1366 tonic::Status,
1367 > {
1368 self.inner
1369 .ready()
1370 .await
1371 .map_err(|e| {
1372 tonic::Status::unknown(
1373 format!("Service was not ready: {}", e.into()),
1374 )
1375 })?;
1376 let codec = tonic::codec::ProstCodec::default();
1377 let path = http::uri::PathAndQuery::from_static(
1378 "/ddl_service.DdlService/DropMaterializedView",
1379 );
1380 let mut req = request.into_request();
1381 req.extensions_mut()
1382 .insert(
1383 GrpcMethod::new("ddl_service.DdlService", "DropMaterializedView"),
1384 );
1385 self.inner.unary(req, path, codec).await
1386 }
1387 pub async fn create_table(
1388 &mut self,
1389 request: impl tonic::IntoRequest<super::CreateTableRequest>,
1390 ) -> std::result::Result<
1391 tonic::Response<super::CreateTableResponse>,
1392 tonic::Status,
1393 > {
1394 self.inner
1395 .ready()
1396 .await
1397 .map_err(|e| {
1398 tonic::Status::unknown(
1399 format!("Service was not ready: {}", e.into()),
1400 )
1401 })?;
1402 let codec = tonic::codec::ProstCodec::default();
1403 let path = http::uri::PathAndQuery::from_static(
1404 "/ddl_service.DdlService/CreateTable",
1405 );
1406 let mut req = request.into_request();
1407 req.extensions_mut()
1408 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateTable"));
1409 self.inner.unary(req, path, codec).await
1410 }
1411 pub async fn create_secret(
1412 &mut self,
1413 request: impl tonic::IntoRequest<super::CreateSecretRequest>,
1414 ) -> std::result::Result<
1415 tonic::Response<super::CreateSecretResponse>,
1416 tonic::Status,
1417 > {
1418 self.inner
1419 .ready()
1420 .await
1421 .map_err(|e| {
1422 tonic::Status::unknown(
1423 format!("Service was not ready: {}", e.into()),
1424 )
1425 })?;
1426 let codec = tonic::codec::ProstCodec::default();
1427 let path = http::uri::PathAndQuery::from_static(
1428 "/ddl_service.DdlService/CreateSecret",
1429 );
1430 let mut req = request.into_request();
1431 req.extensions_mut()
1432 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSecret"));
1433 self.inner.unary(req, path, codec).await
1434 }
1435 pub async fn drop_secret(
1436 &mut self,
1437 request: impl tonic::IntoRequest<super::DropSecretRequest>,
1438 ) -> std::result::Result<
1439 tonic::Response<super::DropSecretResponse>,
1440 tonic::Status,
1441 > {
1442 self.inner
1443 .ready()
1444 .await
1445 .map_err(|e| {
1446 tonic::Status::unknown(
1447 format!("Service was not ready: {}", e.into()),
1448 )
1449 })?;
1450 let codec = tonic::codec::ProstCodec::default();
1451 let path = http::uri::PathAndQuery::from_static(
1452 "/ddl_service.DdlService/DropSecret",
1453 );
1454 let mut req = request.into_request();
1455 req.extensions_mut()
1456 .insert(GrpcMethod::new("ddl_service.DdlService", "DropSecret"));
1457 self.inner.unary(req, path, codec).await
1458 }
1459 pub async fn alter_secret(
1460 &mut self,
1461 request: impl tonic::IntoRequest<super::AlterSecretRequest>,
1462 ) -> std::result::Result<
1463 tonic::Response<super::AlterSecretResponse>,
1464 tonic::Status,
1465 > {
1466 self.inner
1467 .ready()
1468 .await
1469 .map_err(|e| {
1470 tonic::Status::unknown(
1471 format!("Service was not ready: {}", e.into()),
1472 )
1473 })?;
1474 let codec = tonic::codec::ProstCodec::default();
1475 let path = http::uri::PathAndQuery::from_static(
1476 "/ddl_service.DdlService/AlterSecret",
1477 );
1478 let mut req = request.into_request();
1479 req.extensions_mut()
1480 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSecret"));
1481 self.inner.unary(req, path, codec).await
1482 }
1483 pub async fn alter_name(
1484 &mut self,
1485 request: impl tonic::IntoRequest<super::AlterNameRequest>,
1486 ) -> std::result::Result<
1487 tonic::Response<super::AlterNameResponse>,
1488 tonic::Status,
1489 > {
1490 self.inner
1491 .ready()
1492 .await
1493 .map_err(|e| {
1494 tonic::Status::unknown(
1495 format!("Service was not ready: {}", e.into()),
1496 )
1497 })?;
1498 let codec = tonic::codec::ProstCodec::default();
1499 let path = http::uri::PathAndQuery::from_static(
1500 "/ddl_service.DdlService/AlterName",
1501 );
1502 let mut req = request.into_request();
1503 req.extensions_mut()
1504 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterName"));
1505 self.inner.unary(req, path, codec).await
1506 }
1507 pub async fn alter_source(
1508 &mut self,
1509 request: impl tonic::IntoRequest<super::AlterSourceRequest>,
1510 ) -> std::result::Result<
1511 tonic::Response<super::AlterSourceResponse>,
1512 tonic::Status,
1513 > {
1514 self.inner
1515 .ready()
1516 .await
1517 .map_err(|e| {
1518 tonic::Status::unknown(
1519 format!("Service was not ready: {}", e.into()),
1520 )
1521 })?;
1522 let codec = tonic::codec::ProstCodec::default();
1523 let path = http::uri::PathAndQuery::from_static(
1524 "/ddl_service.DdlService/AlterSource",
1525 );
1526 let mut req = request.into_request();
1527 req.extensions_mut()
1528 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSource"));
1529 self.inner.unary(req, path, codec).await
1530 }
1531 pub async fn alter_owner(
1532 &mut self,
1533 request: impl tonic::IntoRequest<super::AlterOwnerRequest>,
1534 ) -> std::result::Result<
1535 tonic::Response<super::AlterOwnerResponse>,
1536 tonic::Status,
1537 > {
1538 self.inner
1539 .ready()
1540 .await
1541 .map_err(|e| {
1542 tonic::Status::unknown(
1543 format!("Service was not ready: {}", e.into()),
1544 )
1545 })?;
1546 let codec = tonic::codec::ProstCodec::default();
1547 let path = http::uri::PathAndQuery::from_static(
1548 "/ddl_service.DdlService/AlterOwner",
1549 );
1550 let mut req = request.into_request();
1551 req.extensions_mut()
1552 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterOwner"));
1553 self.inner.unary(req, path, codec).await
1554 }
1555 pub async fn alter_set_schema(
1556 &mut self,
1557 request: impl tonic::IntoRequest<super::AlterSetSchemaRequest>,
1558 ) -> std::result::Result<
1559 tonic::Response<super::AlterSetSchemaResponse>,
1560 tonic::Status,
1561 > {
1562 self.inner
1563 .ready()
1564 .await
1565 .map_err(|e| {
1566 tonic::Status::unknown(
1567 format!("Service was not ready: {}", e.into()),
1568 )
1569 })?;
1570 let codec = tonic::codec::ProstCodec::default();
1571 let path = http::uri::PathAndQuery::from_static(
1572 "/ddl_service.DdlService/AlterSetSchema",
1573 );
1574 let mut req = request.into_request();
1575 req.extensions_mut()
1576 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSetSchema"));
1577 self.inner.unary(req, path, codec).await
1578 }
1579 pub async fn alter_parallelism(
1580 &mut self,
1581 request: impl tonic::IntoRequest<super::AlterParallelismRequest>,
1582 ) -> std::result::Result<
1583 tonic::Response<super::AlterParallelismResponse>,
1584 tonic::Status,
1585 > {
1586 self.inner
1587 .ready()
1588 .await
1589 .map_err(|e| {
1590 tonic::Status::unknown(
1591 format!("Service was not ready: {}", e.into()),
1592 )
1593 })?;
1594 let codec = tonic::codec::ProstCodec::default();
1595 let path = http::uri::PathAndQuery::from_static(
1596 "/ddl_service.DdlService/AlterParallelism",
1597 );
1598 let mut req = request.into_request();
1599 req.extensions_mut()
1600 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterParallelism"));
1601 self.inner.unary(req, path, codec).await
1602 }
1603 pub async fn alter_resource_group(
1604 &mut self,
1605 request: impl tonic::IntoRequest<super::AlterResourceGroupRequest>,
1606 ) -> std::result::Result<
1607 tonic::Response<super::AlterResourceGroupResponse>,
1608 tonic::Status,
1609 > {
1610 self.inner
1611 .ready()
1612 .await
1613 .map_err(|e| {
1614 tonic::Status::unknown(
1615 format!("Service was not ready: {}", e.into()),
1616 )
1617 })?;
1618 let codec = tonic::codec::ProstCodec::default();
1619 let path = http::uri::PathAndQuery::from_static(
1620 "/ddl_service.DdlService/AlterResourceGroup",
1621 );
1622 let mut req = request.into_request();
1623 req.extensions_mut()
1624 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterResourceGroup"));
1625 self.inner.unary(req, path, codec).await
1626 }
1627 pub async fn drop_table(
1628 &mut self,
1629 request: impl tonic::IntoRequest<super::DropTableRequest>,
1630 ) -> std::result::Result<
1631 tonic::Response<super::DropTableResponse>,
1632 tonic::Status,
1633 > {
1634 self.inner
1635 .ready()
1636 .await
1637 .map_err(|e| {
1638 tonic::Status::unknown(
1639 format!("Service was not ready: {}", e.into()),
1640 )
1641 })?;
1642 let codec = tonic::codec::ProstCodec::default();
1643 let path = http::uri::PathAndQuery::from_static(
1644 "/ddl_service.DdlService/DropTable",
1645 );
1646 let mut req = request.into_request();
1647 req.extensions_mut()
1648 .insert(GrpcMethod::new("ddl_service.DdlService", "DropTable"));
1649 self.inner.unary(req, path, codec).await
1650 }
1651 pub async fn risectl_list_state_tables(
1652 &mut self,
1653 request: impl tonic::IntoRequest<super::RisectlListStateTablesRequest>,
1654 ) -> std::result::Result<
1655 tonic::Response<super::RisectlListStateTablesResponse>,
1656 tonic::Status,
1657 > {
1658 self.inner
1659 .ready()
1660 .await
1661 .map_err(|e| {
1662 tonic::Status::unknown(
1663 format!("Service was not ready: {}", e.into()),
1664 )
1665 })?;
1666 let codec = tonic::codec::ProstCodec::default();
1667 let path = http::uri::PathAndQuery::from_static(
1668 "/ddl_service.DdlService/RisectlListStateTables",
1669 );
1670 let mut req = request.into_request();
1671 req.extensions_mut()
1672 .insert(
1673 GrpcMethod::new("ddl_service.DdlService", "RisectlListStateTables"),
1674 );
1675 self.inner.unary(req, path, codec).await
1676 }
1677 pub async fn create_view(
1678 &mut self,
1679 request: impl tonic::IntoRequest<super::CreateViewRequest>,
1680 ) -> std::result::Result<
1681 tonic::Response<super::CreateViewResponse>,
1682 tonic::Status,
1683 > {
1684 self.inner
1685 .ready()
1686 .await
1687 .map_err(|e| {
1688 tonic::Status::unknown(
1689 format!("Service was not ready: {}", e.into()),
1690 )
1691 })?;
1692 let codec = tonic::codec::ProstCodec::default();
1693 let path = http::uri::PathAndQuery::from_static(
1694 "/ddl_service.DdlService/CreateView",
1695 );
1696 let mut req = request.into_request();
1697 req.extensions_mut()
1698 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateView"));
1699 self.inner.unary(req, path, codec).await
1700 }
1701 pub async fn drop_view(
1702 &mut self,
1703 request: impl tonic::IntoRequest<super::DropViewRequest>,
1704 ) -> std::result::Result<
1705 tonic::Response<super::DropViewResponse>,
1706 tonic::Status,
1707 > {
1708 self.inner
1709 .ready()
1710 .await
1711 .map_err(|e| {
1712 tonic::Status::unknown(
1713 format!("Service was not ready: {}", e.into()),
1714 )
1715 })?;
1716 let codec = tonic::codec::ProstCodec::default();
1717 let path = http::uri::PathAndQuery::from_static(
1718 "/ddl_service.DdlService/DropView",
1719 );
1720 let mut req = request.into_request();
1721 req.extensions_mut()
1722 .insert(GrpcMethod::new("ddl_service.DdlService", "DropView"));
1723 self.inner.unary(req, path, codec).await
1724 }
1725 pub async fn create_index(
1726 &mut self,
1727 request: impl tonic::IntoRequest<super::CreateIndexRequest>,
1728 ) -> std::result::Result<
1729 tonic::Response<super::CreateIndexResponse>,
1730 tonic::Status,
1731 > {
1732 self.inner
1733 .ready()
1734 .await
1735 .map_err(|e| {
1736 tonic::Status::unknown(
1737 format!("Service was not ready: {}", e.into()),
1738 )
1739 })?;
1740 let codec = tonic::codec::ProstCodec::default();
1741 let path = http::uri::PathAndQuery::from_static(
1742 "/ddl_service.DdlService/CreateIndex",
1743 );
1744 let mut req = request.into_request();
1745 req.extensions_mut()
1746 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateIndex"));
1747 self.inner.unary(req, path, codec).await
1748 }
1749 pub async fn drop_index(
1750 &mut self,
1751 request: impl tonic::IntoRequest<super::DropIndexRequest>,
1752 ) -> std::result::Result<
1753 tonic::Response<super::DropIndexResponse>,
1754 tonic::Status,
1755 > {
1756 self.inner
1757 .ready()
1758 .await
1759 .map_err(|e| {
1760 tonic::Status::unknown(
1761 format!("Service was not ready: {}", e.into()),
1762 )
1763 })?;
1764 let codec = tonic::codec::ProstCodec::default();
1765 let path = http::uri::PathAndQuery::from_static(
1766 "/ddl_service.DdlService/DropIndex",
1767 );
1768 let mut req = request.into_request();
1769 req.extensions_mut()
1770 .insert(GrpcMethod::new("ddl_service.DdlService", "DropIndex"));
1771 self.inner.unary(req, path, codec).await
1772 }
1773 pub async fn create_function(
1774 &mut self,
1775 request: impl tonic::IntoRequest<super::CreateFunctionRequest>,
1776 ) -> std::result::Result<
1777 tonic::Response<super::CreateFunctionResponse>,
1778 tonic::Status,
1779 > {
1780 self.inner
1781 .ready()
1782 .await
1783 .map_err(|e| {
1784 tonic::Status::unknown(
1785 format!("Service was not ready: {}", e.into()),
1786 )
1787 })?;
1788 let codec = tonic::codec::ProstCodec::default();
1789 let path = http::uri::PathAndQuery::from_static(
1790 "/ddl_service.DdlService/CreateFunction",
1791 );
1792 let mut req = request.into_request();
1793 req.extensions_mut()
1794 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateFunction"));
1795 self.inner.unary(req, path, codec).await
1796 }
1797 pub async fn drop_function(
1798 &mut self,
1799 request: impl tonic::IntoRequest<super::DropFunctionRequest>,
1800 ) -> std::result::Result<
1801 tonic::Response<super::DropFunctionResponse>,
1802 tonic::Status,
1803 > {
1804 self.inner
1805 .ready()
1806 .await
1807 .map_err(|e| {
1808 tonic::Status::unknown(
1809 format!("Service was not ready: {}", e.into()),
1810 )
1811 })?;
1812 let codec = tonic::codec::ProstCodec::default();
1813 let path = http::uri::PathAndQuery::from_static(
1814 "/ddl_service.DdlService/DropFunction",
1815 );
1816 let mut req = request.into_request();
1817 req.extensions_mut()
1818 .insert(GrpcMethod::new("ddl_service.DdlService", "DropFunction"));
1819 self.inner.unary(req, path, codec).await
1820 }
1821 pub async fn replace_job_plan(
1822 &mut self,
1823 request: impl tonic::IntoRequest<super::ReplaceJobPlanRequest>,
1824 ) -> std::result::Result<
1825 tonic::Response<super::ReplaceJobPlanResponse>,
1826 tonic::Status,
1827 > {
1828 self.inner
1829 .ready()
1830 .await
1831 .map_err(|e| {
1832 tonic::Status::unknown(
1833 format!("Service was not ready: {}", e.into()),
1834 )
1835 })?;
1836 let codec = tonic::codec::ProstCodec::default();
1837 let path = http::uri::PathAndQuery::from_static(
1838 "/ddl_service.DdlService/ReplaceJobPlan",
1839 );
1840 let mut req = request.into_request();
1841 req.extensions_mut()
1842 .insert(GrpcMethod::new("ddl_service.DdlService", "ReplaceJobPlan"));
1843 self.inner.unary(req, path, codec).await
1844 }
1845 pub async fn get_table(
1846 &mut self,
1847 request: impl tonic::IntoRequest<super::GetTableRequest>,
1848 ) -> std::result::Result<
1849 tonic::Response<super::GetTableResponse>,
1850 tonic::Status,
1851 > {
1852 self.inner
1853 .ready()
1854 .await
1855 .map_err(|e| {
1856 tonic::Status::unknown(
1857 format!("Service was not ready: {}", e.into()),
1858 )
1859 })?;
1860 let codec = tonic::codec::ProstCodec::default();
1861 let path = http::uri::PathAndQuery::from_static(
1862 "/ddl_service.DdlService/GetTable",
1863 );
1864 let mut req = request.into_request();
1865 req.extensions_mut()
1866 .insert(GrpcMethod::new("ddl_service.DdlService", "GetTable"));
1867 self.inner.unary(req, path, codec).await
1868 }
1869 pub async fn get_ddl_progress(
1870 &mut self,
1871 request: impl tonic::IntoRequest<super::GetDdlProgressRequest>,
1872 ) -> std::result::Result<
1873 tonic::Response<super::GetDdlProgressResponse>,
1874 tonic::Status,
1875 > {
1876 self.inner
1877 .ready()
1878 .await
1879 .map_err(|e| {
1880 tonic::Status::unknown(
1881 format!("Service was not ready: {}", e.into()),
1882 )
1883 })?;
1884 let codec = tonic::codec::ProstCodec::default();
1885 let path = http::uri::PathAndQuery::from_static(
1886 "/ddl_service.DdlService/GetDdlProgress",
1887 );
1888 let mut req = request.into_request();
1889 req.extensions_mut()
1890 .insert(GrpcMethod::new("ddl_service.DdlService", "GetDdlProgress"));
1891 self.inner.unary(req, path, codec).await
1892 }
1893 pub async fn create_connection(
1894 &mut self,
1895 request: impl tonic::IntoRequest<super::CreateConnectionRequest>,
1896 ) -> std::result::Result<
1897 tonic::Response<super::CreateConnectionResponse>,
1898 tonic::Status,
1899 > {
1900 self.inner
1901 .ready()
1902 .await
1903 .map_err(|e| {
1904 tonic::Status::unknown(
1905 format!("Service was not ready: {}", e.into()),
1906 )
1907 })?;
1908 let codec = tonic::codec::ProstCodec::default();
1909 let path = http::uri::PathAndQuery::from_static(
1910 "/ddl_service.DdlService/CreateConnection",
1911 );
1912 let mut req = request.into_request();
1913 req.extensions_mut()
1914 .insert(GrpcMethod::new("ddl_service.DdlService", "CreateConnection"));
1915 self.inner.unary(req, path, codec).await
1916 }
1917 pub async fn list_connections(
1918 &mut self,
1919 request: impl tonic::IntoRequest<super::ListConnectionsRequest>,
1920 ) -> std::result::Result<
1921 tonic::Response<super::ListConnectionsResponse>,
1922 tonic::Status,
1923 > {
1924 self.inner
1925 .ready()
1926 .await
1927 .map_err(|e| {
1928 tonic::Status::unknown(
1929 format!("Service was not ready: {}", e.into()),
1930 )
1931 })?;
1932 let codec = tonic::codec::ProstCodec::default();
1933 let path = http::uri::PathAndQuery::from_static(
1934 "/ddl_service.DdlService/ListConnections",
1935 );
1936 let mut req = request.into_request();
1937 req.extensions_mut()
1938 .insert(GrpcMethod::new("ddl_service.DdlService", "ListConnections"));
1939 self.inner.unary(req, path, codec).await
1940 }
1941 pub async fn drop_connection(
1942 &mut self,
1943 request: impl tonic::IntoRequest<super::DropConnectionRequest>,
1944 ) -> std::result::Result<
1945 tonic::Response<super::DropConnectionResponse>,
1946 tonic::Status,
1947 > {
1948 self.inner
1949 .ready()
1950 .await
1951 .map_err(|e| {
1952 tonic::Status::unknown(
1953 format!("Service was not ready: {}", e.into()),
1954 )
1955 })?;
1956 let codec = tonic::codec::ProstCodec::default();
1957 let path = http::uri::PathAndQuery::from_static(
1958 "/ddl_service.DdlService/DropConnection",
1959 );
1960 let mut req = request.into_request();
1961 req.extensions_mut()
1962 .insert(GrpcMethod::new("ddl_service.DdlService", "DropConnection"));
1963 self.inner.unary(req, path, codec).await
1964 }
1965 pub async fn get_tables(
1966 &mut self,
1967 request: impl tonic::IntoRequest<super::GetTablesRequest>,
1968 ) -> std::result::Result<
1969 tonic::Response<super::GetTablesResponse>,
1970 tonic::Status,
1971 > {
1972 self.inner
1973 .ready()
1974 .await
1975 .map_err(|e| {
1976 tonic::Status::unknown(
1977 format!("Service was not ready: {}", e.into()),
1978 )
1979 })?;
1980 let codec = tonic::codec::ProstCodec::default();
1981 let path = http::uri::PathAndQuery::from_static(
1982 "/ddl_service.DdlService/GetTables",
1983 );
1984 let mut req = request.into_request();
1985 req.extensions_mut()
1986 .insert(GrpcMethod::new("ddl_service.DdlService", "GetTables"));
1987 self.inner.unary(req, path, codec).await
1988 }
1989 pub async fn wait(
1990 &mut self,
1991 request: impl tonic::IntoRequest<super::WaitRequest>,
1992 ) -> std::result::Result<tonic::Response<super::WaitResponse>, tonic::Status> {
1993 self.inner
1994 .ready()
1995 .await
1996 .map_err(|e| {
1997 tonic::Status::unknown(
1998 format!("Service was not ready: {}", e.into()),
1999 )
2000 })?;
2001 let codec = tonic::codec::ProstCodec::default();
2002 let path = http::uri::PathAndQuery::from_static(
2003 "/ddl_service.DdlService/Wait",
2004 );
2005 let mut req = request.into_request();
2006 req.extensions_mut()
2007 .insert(GrpcMethod::new("ddl_service.DdlService", "Wait"));
2008 self.inner.unary(req, path, codec).await
2009 }
2010 pub async fn comment_on(
2011 &mut self,
2012 request: impl tonic::IntoRequest<super::CommentOnRequest>,
2013 ) -> std::result::Result<
2014 tonic::Response<super::CommentOnResponse>,
2015 tonic::Status,
2016 > {
2017 self.inner
2018 .ready()
2019 .await
2020 .map_err(|e| {
2021 tonic::Status::unknown(
2022 format!("Service was not ready: {}", e.into()),
2023 )
2024 })?;
2025 let codec = tonic::codec::ProstCodec::default();
2026 let path = http::uri::PathAndQuery::from_static(
2027 "/ddl_service.DdlService/CommentOn",
2028 );
2029 let mut req = request.into_request();
2030 req.extensions_mut()
2031 .insert(GrpcMethod::new("ddl_service.DdlService", "CommentOn"));
2032 self.inner.unary(req, path, codec).await
2033 }
2034 pub async fn auto_schema_change(
2035 &mut self,
2036 request: impl tonic::IntoRequest<super::AutoSchemaChangeRequest>,
2037 ) -> std::result::Result<
2038 tonic::Response<super::AutoSchemaChangeResponse>,
2039 tonic::Status,
2040 > {
2041 self.inner
2042 .ready()
2043 .await
2044 .map_err(|e| {
2045 tonic::Status::unknown(
2046 format!("Service was not ready: {}", e.into()),
2047 )
2048 })?;
2049 let codec = tonic::codec::ProstCodec::default();
2050 let path = http::uri::PathAndQuery::from_static(
2051 "/ddl_service.DdlService/AutoSchemaChange",
2052 );
2053 let mut req = request.into_request();
2054 req.extensions_mut()
2055 .insert(GrpcMethod::new("ddl_service.DdlService", "AutoSchemaChange"));
2056 self.inner.unary(req, path, codec).await
2057 }
2058 pub async fn alter_swap_rename(
2059 &mut self,
2060 request: impl tonic::IntoRequest<super::AlterSwapRenameRequest>,
2061 ) -> std::result::Result<
2062 tonic::Response<super::AlterSwapRenameResponse>,
2063 tonic::Status,
2064 > {
2065 self.inner
2066 .ready()
2067 .await
2068 .map_err(|e| {
2069 tonic::Status::unknown(
2070 format!("Service was not ready: {}", e.into()),
2071 )
2072 })?;
2073 let codec = tonic::codec::ProstCodec::default();
2074 let path = http::uri::PathAndQuery::from_static(
2075 "/ddl_service.DdlService/AlterSwapRename",
2076 );
2077 let mut req = request.into_request();
2078 req.extensions_mut()
2079 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSwapRename"));
2080 self.inner.unary(req, path, codec).await
2081 }
2082 pub async fn alter_database_param(
2083 &mut self,
2084 request: impl tonic::IntoRequest<super::AlterDatabaseParamRequest>,
2085 ) -> std::result::Result<
2086 tonic::Response<super::AlterDatabaseParamResponse>,
2087 tonic::Status,
2088 > {
2089 self.inner
2090 .ready()
2091 .await
2092 .map_err(|e| {
2093 tonic::Status::unknown(
2094 format!("Service was not ready: {}", e.into()),
2095 )
2096 })?;
2097 let codec = tonic::codec::ProstCodec::default();
2098 let path = http::uri::PathAndQuery::from_static(
2099 "/ddl_service.DdlService/AlterDatabaseParam",
2100 );
2101 let mut req = request.into_request();
2102 req.extensions_mut()
2103 .insert(GrpcMethod::new("ddl_service.DdlService", "AlterDatabaseParam"));
2104 self.inner.unary(req, path, codec).await
2105 }
2106 }
2107}
2108pub mod ddl_service_server {
2110 #![allow(
2111 unused_variables,
2112 dead_code,
2113 missing_docs,
2114 clippy::wildcard_imports,
2115 clippy::let_unit_value,
2116 )]
2117 use tonic::codegen::*;
2118 #[async_trait]
2120 pub trait DdlService: std::marker::Send + std::marker::Sync + 'static {
2121 async fn create_database(
2122 &self,
2123 request: tonic::Request<super::CreateDatabaseRequest>,
2124 ) -> std::result::Result<
2125 tonic::Response<super::CreateDatabaseResponse>,
2126 tonic::Status,
2127 >;
2128 async fn drop_database(
2129 &self,
2130 request: tonic::Request<super::DropDatabaseRequest>,
2131 ) -> std::result::Result<
2132 tonic::Response<super::DropDatabaseResponse>,
2133 tonic::Status,
2134 >;
2135 async fn create_schema(
2136 &self,
2137 request: tonic::Request<super::CreateSchemaRequest>,
2138 ) -> std::result::Result<
2139 tonic::Response<super::CreateSchemaResponse>,
2140 tonic::Status,
2141 >;
2142 async fn drop_schema(
2143 &self,
2144 request: tonic::Request<super::DropSchemaRequest>,
2145 ) -> std::result::Result<
2146 tonic::Response<super::DropSchemaResponse>,
2147 tonic::Status,
2148 >;
2149 async fn create_source(
2150 &self,
2151 request: tonic::Request<super::CreateSourceRequest>,
2152 ) -> std::result::Result<
2153 tonic::Response<super::CreateSourceResponse>,
2154 tonic::Status,
2155 >;
2156 async fn drop_source(
2157 &self,
2158 request: tonic::Request<super::DropSourceRequest>,
2159 ) -> std::result::Result<
2160 tonic::Response<super::DropSourceResponse>,
2161 tonic::Status,
2162 >;
2163 async fn create_sink(
2164 &self,
2165 request: tonic::Request<super::CreateSinkRequest>,
2166 ) -> std::result::Result<
2167 tonic::Response<super::CreateSinkResponse>,
2168 tonic::Status,
2169 >;
2170 async fn create_subscription(
2171 &self,
2172 request: tonic::Request<super::CreateSubscriptionRequest>,
2173 ) -> std::result::Result<
2174 tonic::Response<super::CreateSubscriptionResponse>,
2175 tonic::Status,
2176 >;
2177 async fn drop_sink(
2178 &self,
2179 request: tonic::Request<super::DropSinkRequest>,
2180 ) -> std::result::Result<
2181 tonic::Response<super::DropSinkResponse>,
2182 tonic::Status,
2183 >;
2184 async fn drop_subscription(
2185 &self,
2186 request: tonic::Request<super::DropSubscriptionRequest>,
2187 ) -> std::result::Result<
2188 tonic::Response<super::DropSubscriptionResponse>,
2189 tonic::Status,
2190 >;
2191 async fn create_materialized_view(
2192 &self,
2193 request: tonic::Request<super::CreateMaterializedViewRequest>,
2194 ) -> std::result::Result<
2195 tonic::Response<super::CreateMaterializedViewResponse>,
2196 tonic::Status,
2197 >;
2198 async fn drop_materialized_view(
2199 &self,
2200 request: tonic::Request<super::DropMaterializedViewRequest>,
2201 ) -> std::result::Result<
2202 tonic::Response<super::DropMaterializedViewResponse>,
2203 tonic::Status,
2204 >;
2205 async fn create_table(
2206 &self,
2207 request: tonic::Request<super::CreateTableRequest>,
2208 ) -> std::result::Result<
2209 tonic::Response<super::CreateTableResponse>,
2210 tonic::Status,
2211 >;
2212 async fn create_secret(
2213 &self,
2214 request: tonic::Request<super::CreateSecretRequest>,
2215 ) -> std::result::Result<
2216 tonic::Response<super::CreateSecretResponse>,
2217 tonic::Status,
2218 >;
2219 async fn drop_secret(
2220 &self,
2221 request: tonic::Request<super::DropSecretRequest>,
2222 ) -> std::result::Result<
2223 tonic::Response<super::DropSecretResponse>,
2224 tonic::Status,
2225 >;
2226 async fn alter_secret(
2227 &self,
2228 request: tonic::Request<super::AlterSecretRequest>,
2229 ) -> std::result::Result<
2230 tonic::Response<super::AlterSecretResponse>,
2231 tonic::Status,
2232 >;
2233 async fn alter_name(
2234 &self,
2235 request: tonic::Request<super::AlterNameRequest>,
2236 ) -> std::result::Result<
2237 tonic::Response<super::AlterNameResponse>,
2238 tonic::Status,
2239 >;
2240 async fn alter_source(
2241 &self,
2242 request: tonic::Request<super::AlterSourceRequest>,
2243 ) -> std::result::Result<
2244 tonic::Response<super::AlterSourceResponse>,
2245 tonic::Status,
2246 >;
2247 async fn alter_owner(
2248 &self,
2249 request: tonic::Request<super::AlterOwnerRequest>,
2250 ) -> std::result::Result<
2251 tonic::Response<super::AlterOwnerResponse>,
2252 tonic::Status,
2253 >;
2254 async fn alter_set_schema(
2255 &self,
2256 request: tonic::Request<super::AlterSetSchemaRequest>,
2257 ) -> std::result::Result<
2258 tonic::Response<super::AlterSetSchemaResponse>,
2259 tonic::Status,
2260 >;
2261 async fn alter_parallelism(
2262 &self,
2263 request: tonic::Request<super::AlterParallelismRequest>,
2264 ) -> std::result::Result<
2265 tonic::Response<super::AlterParallelismResponse>,
2266 tonic::Status,
2267 >;
2268 async fn alter_resource_group(
2269 &self,
2270 request: tonic::Request<super::AlterResourceGroupRequest>,
2271 ) -> std::result::Result<
2272 tonic::Response<super::AlterResourceGroupResponse>,
2273 tonic::Status,
2274 >;
2275 async fn drop_table(
2276 &self,
2277 request: tonic::Request<super::DropTableRequest>,
2278 ) -> std::result::Result<
2279 tonic::Response<super::DropTableResponse>,
2280 tonic::Status,
2281 >;
2282 async fn risectl_list_state_tables(
2283 &self,
2284 request: tonic::Request<super::RisectlListStateTablesRequest>,
2285 ) -> std::result::Result<
2286 tonic::Response<super::RisectlListStateTablesResponse>,
2287 tonic::Status,
2288 >;
2289 async fn create_view(
2290 &self,
2291 request: tonic::Request<super::CreateViewRequest>,
2292 ) -> std::result::Result<
2293 tonic::Response<super::CreateViewResponse>,
2294 tonic::Status,
2295 >;
2296 async fn drop_view(
2297 &self,
2298 request: tonic::Request<super::DropViewRequest>,
2299 ) -> std::result::Result<
2300 tonic::Response<super::DropViewResponse>,
2301 tonic::Status,
2302 >;
2303 async fn create_index(
2304 &self,
2305 request: tonic::Request<super::CreateIndexRequest>,
2306 ) -> std::result::Result<
2307 tonic::Response<super::CreateIndexResponse>,
2308 tonic::Status,
2309 >;
2310 async fn drop_index(
2311 &self,
2312 request: tonic::Request<super::DropIndexRequest>,
2313 ) -> std::result::Result<
2314 tonic::Response<super::DropIndexResponse>,
2315 tonic::Status,
2316 >;
2317 async fn create_function(
2318 &self,
2319 request: tonic::Request<super::CreateFunctionRequest>,
2320 ) -> std::result::Result<
2321 tonic::Response<super::CreateFunctionResponse>,
2322 tonic::Status,
2323 >;
2324 async fn drop_function(
2325 &self,
2326 request: tonic::Request<super::DropFunctionRequest>,
2327 ) -> std::result::Result<
2328 tonic::Response<super::DropFunctionResponse>,
2329 tonic::Status,
2330 >;
2331 async fn replace_job_plan(
2332 &self,
2333 request: tonic::Request<super::ReplaceJobPlanRequest>,
2334 ) -> std::result::Result<
2335 tonic::Response<super::ReplaceJobPlanResponse>,
2336 tonic::Status,
2337 >;
2338 async fn get_table(
2339 &self,
2340 request: tonic::Request<super::GetTableRequest>,
2341 ) -> std::result::Result<
2342 tonic::Response<super::GetTableResponse>,
2343 tonic::Status,
2344 >;
2345 async fn get_ddl_progress(
2346 &self,
2347 request: tonic::Request<super::GetDdlProgressRequest>,
2348 ) -> std::result::Result<
2349 tonic::Response<super::GetDdlProgressResponse>,
2350 tonic::Status,
2351 >;
2352 async fn create_connection(
2353 &self,
2354 request: tonic::Request<super::CreateConnectionRequest>,
2355 ) -> std::result::Result<
2356 tonic::Response<super::CreateConnectionResponse>,
2357 tonic::Status,
2358 >;
2359 async fn list_connections(
2360 &self,
2361 request: tonic::Request<super::ListConnectionsRequest>,
2362 ) -> std::result::Result<
2363 tonic::Response<super::ListConnectionsResponse>,
2364 tonic::Status,
2365 >;
2366 async fn drop_connection(
2367 &self,
2368 request: tonic::Request<super::DropConnectionRequest>,
2369 ) -> std::result::Result<
2370 tonic::Response<super::DropConnectionResponse>,
2371 tonic::Status,
2372 >;
2373 async fn get_tables(
2374 &self,
2375 request: tonic::Request<super::GetTablesRequest>,
2376 ) -> std::result::Result<
2377 tonic::Response<super::GetTablesResponse>,
2378 tonic::Status,
2379 >;
2380 async fn wait(
2381 &self,
2382 request: tonic::Request<super::WaitRequest>,
2383 ) -> std::result::Result<tonic::Response<super::WaitResponse>, tonic::Status>;
2384 async fn comment_on(
2385 &self,
2386 request: tonic::Request<super::CommentOnRequest>,
2387 ) -> std::result::Result<
2388 tonic::Response<super::CommentOnResponse>,
2389 tonic::Status,
2390 >;
2391 async fn auto_schema_change(
2392 &self,
2393 request: tonic::Request<super::AutoSchemaChangeRequest>,
2394 ) -> std::result::Result<
2395 tonic::Response<super::AutoSchemaChangeResponse>,
2396 tonic::Status,
2397 >;
2398 async fn alter_swap_rename(
2399 &self,
2400 request: tonic::Request<super::AlterSwapRenameRequest>,
2401 ) -> std::result::Result<
2402 tonic::Response<super::AlterSwapRenameResponse>,
2403 tonic::Status,
2404 >;
2405 async fn alter_database_param(
2406 &self,
2407 request: tonic::Request<super::AlterDatabaseParamRequest>,
2408 ) -> std::result::Result<
2409 tonic::Response<super::AlterDatabaseParamResponse>,
2410 tonic::Status,
2411 >;
2412 }
2413 #[derive(Debug)]
2414 pub struct DdlServiceServer<T> {
2415 inner: Arc<T>,
2416 accept_compression_encodings: EnabledCompressionEncodings,
2417 send_compression_encodings: EnabledCompressionEncodings,
2418 max_decoding_message_size: Option<usize>,
2419 max_encoding_message_size: Option<usize>,
2420 }
2421 impl<T> DdlServiceServer<T> {
2422 pub fn new(inner: T) -> Self {
2423 Self::from_arc(Arc::new(inner))
2424 }
2425 pub fn from_arc(inner: Arc<T>) -> Self {
2426 Self {
2427 inner,
2428 accept_compression_encodings: Default::default(),
2429 send_compression_encodings: Default::default(),
2430 max_decoding_message_size: None,
2431 max_encoding_message_size: None,
2432 }
2433 }
2434 pub fn with_interceptor<F>(
2435 inner: T,
2436 interceptor: F,
2437 ) -> InterceptedService<Self, F>
2438 where
2439 F: tonic::service::Interceptor,
2440 {
2441 InterceptedService::new(Self::new(inner), interceptor)
2442 }
2443 #[must_use]
2445 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2446 self.accept_compression_encodings.enable(encoding);
2447 self
2448 }
2449 #[must_use]
2451 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2452 self.send_compression_encodings.enable(encoding);
2453 self
2454 }
2455 #[must_use]
2459 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2460 self.max_decoding_message_size = Some(limit);
2461 self
2462 }
2463 #[must_use]
2467 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2468 self.max_encoding_message_size = Some(limit);
2469 self
2470 }
2471 }
2472 impl<T, B> tonic::codegen::Service<http::Request<B>> for DdlServiceServer<T>
2473 where
2474 T: DdlService,
2475 B: Body + std::marker::Send + 'static,
2476 B::Error: Into<StdError> + std::marker::Send + 'static,
2477 {
2478 type Response = http::Response<tonic::body::BoxBody>;
2479 type Error = std::convert::Infallible;
2480 type Future = BoxFuture<Self::Response, Self::Error>;
2481 fn poll_ready(
2482 &mut self,
2483 _cx: &mut Context<'_>,
2484 ) -> Poll<std::result::Result<(), Self::Error>> {
2485 Poll::Ready(Ok(()))
2486 }
2487 fn call(&mut self, req: http::Request<B>) -> Self::Future {
2488 match req.uri().path() {
2489 "/ddl_service.DdlService/CreateDatabase" => {
2490 #[allow(non_camel_case_types)]
2491 struct CreateDatabaseSvc<T: DdlService>(pub Arc<T>);
2492 impl<
2493 T: DdlService,
2494 > tonic::server::UnaryService<super::CreateDatabaseRequest>
2495 for CreateDatabaseSvc<T> {
2496 type Response = super::CreateDatabaseResponse;
2497 type Future = BoxFuture<
2498 tonic::Response<Self::Response>,
2499 tonic::Status,
2500 >;
2501 fn call(
2502 &mut self,
2503 request: tonic::Request<super::CreateDatabaseRequest>,
2504 ) -> Self::Future {
2505 let inner = Arc::clone(&self.0);
2506 let fut = async move {
2507 <T as DdlService>::create_database(&inner, request).await
2508 };
2509 Box::pin(fut)
2510 }
2511 }
2512 let accept_compression_encodings = self.accept_compression_encodings;
2513 let send_compression_encodings = self.send_compression_encodings;
2514 let max_decoding_message_size = self.max_decoding_message_size;
2515 let max_encoding_message_size = self.max_encoding_message_size;
2516 let inner = self.inner.clone();
2517 let fut = async move {
2518 let method = CreateDatabaseSvc(inner);
2519 let codec = tonic::codec::ProstCodec::default();
2520 let mut grpc = tonic::server::Grpc::new(codec)
2521 .apply_compression_config(
2522 accept_compression_encodings,
2523 send_compression_encodings,
2524 )
2525 .apply_max_message_size_config(
2526 max_decoding_message_size,
2527 max_encoding_message_size,
2528 );
2529 let res = grpc.unary(method, req).await;
2530 Ok(res)
2531 };
2532 Box::pin(fut)
2533 }
2534 "/ddl_service.DdlService/DropDatabase" => {
2535 #[allow(non_camel_case_types)]
2536 struct DropDatabaseSvc<T: DdlService>(pub Arc<T>);
2537 impl<
2538 T: DdlService,
2539 > tonic::server::UnaryService<super::DropDatabaseRequest>
2540 for DropDatabaseSvc<T> {
2541 type Response = super::DropDatabaseResponse;
2542 type Future = BoxFuture<
2543 tonic::Response<Self::Response>,
2544 tonic::Status,
2545 >;
2546 fn call(
2547 &mut self,
2548 request: tonic::Request<super::DropDatabaseRequest>,
2549 ) -> Self::Future {
2550 let inner = Arc::clone(&self.0);
2551 let fut = async move {
2552 <T as DdlService>::drop_database(&inner, request).await
2553 };
2554 Box::pin(fut)
2555 }
2556 }
2557 let accept_compression_encodings = self.accept_compression_encodings;
2558 let send_compression_encodings = self.send_compression_encodings;
2559 let max_decoding_message_size = self.max_decoding_message_size;
2560 let max_encoding_message_size = self.max_encoding_message_size;
2561 let inner = self.inner.clone();
2562 let fut = async move {
2563 let method = DropDatabaseSvc(inner);
2564 let codec = tonic::codec::ProstCodec::default();
2565 let mut grpc = tonic::server::Grpc::new(codec)
2566 .apply_compression_config(
2567 accept_compression_encodings,
2568 send_compression_encodings,
2569 )
2570 .apply_max_message_size_config(
2571 max_decoding_message_size,
2572 max_encoding_message_size,
2573 );
2574 let res = grpc.unary(method, req).await;
2575 Ok(res)
2576 };
2577 Box::pin(fut)
2578 }
2579 "/ddl_service.DdlService/CreateSchema" => {
2580 #[allow(non_camel_case_types)]
2581 struct CreateSchemaSvc<T: DdlService>(pub Arc<T>);
2582 impl<
2583 T: DdlService,
2584 > tonic::server::UnaryService<super::CreateSchemaRequest>
2585 for CreateSchemaSvc<T> {
2586 type Response = super::CreateSchemaResponse;
2587 type Future = BoxFuture<
2588 tonic::Response<Self::Response>,
2589 tonic::Status,
2590 >;
2591 fn call(
2592 &mut self,
2593 request: tonic::Request<super::CreateSchemaRequest>,
2594 ) -> Self::Future {
2595 let inner = Arc::clone(&self.0);
2596 let fut = async move {
2597 <T as DdlService>::create_schema(&inner, request).await
2598 };
2599 Box::pin(fut)
2600 }
2601 }
2602 let accept_compression_encodings = self.accept_compression_encodings;
2603 let send_compression_encodings = self.send_compression_encodings;
2604 let max_decoding_message_size = self.max_decoding_message_size;
2605 let max_encoding_message_size = self.max_encoding_message_size;
2606 let inner = self.inner.clone();
2607 let fut = async move {
2608 let method = CreateSchemaSvc(inner);
2609 let codec = tonic::codec::ProstCodec::default();
2610 let mut grpc = tonic::server::Grpc::new(codec)
2611 .apply_compression_config(
2612 accept_compression_encodings,
2613 send_compression_encodings,
2614 )
2615 .apply_max_message_size_config(
2616 max_decoding_message_size,
2617 max_encoding_message_size,
2618 );
2619 let res = grpc.unary(method, req).await;
2620 Ok(res)
2621 };
2622 Box::pin(fut)
2623 }
2624 "/ddl_service.DdlService/DropSchema" => {
2625 #[allow(non_camel_case_types)]
2626 struct DropSchemaSvc<T: DdlService>(pub Arc<T>);
2627 impl<
2628 T: DdlService,
2629 > tonic::server::UnaryService<super::DropSchemaRequest>
2630 for DropSchemaSvc<T> {
2631 type Response = super::DropSchemaResponse;
2632 type Future = BoxFuture<
2633 tonic::Response<Self::Response>,
2634 tonic::Status,
2635 >;
2636 fn call(
2637 &mut self,
2638 request: tonic::Request<super::DropSchemaRequest>,
2639 ) -> Self::Future {
2640 let inner = Arc::clone(&self.0);
2641 let fut = async move {
2642 <T as DdlService>::drop_schema(&inner, request).await
2643 };
2644 Box::pin(fut)
2645 }
2646 }
2647 let accept_compression_encodings = self.accept_compression_encodings;
2648 let send_compression_encodings = self.send_compression_encodings;
2649 let max_decoding_message_size = self.max_decoding_message_size;
2650 let max_encoding_message_size = self.max_encoding_message_size;
2651 let inner = self.inner.clone();
2652 let fut = async move {
2653 let method = DropSchemaSvc(inner);
2654 let codec = tonic::codec::ProstCodec::default();
2655 let mut grpc = tonic::server::Grpc::new(codec)
2656 .apply_compression_config(
2657 accept_compression_encodings,
2658 send_compression_encodings,
2659 )
2660 .apply_max_message_size_config(
2661 max_decoding_message_size,
2662 max_encoding_message_size,
2663 );
2664 let res = grpc.unary(method, req).await;
2665 Ok(res)
2666 };
2667 Box::pin(fut)
2668 }
2669 "/ddl_service.DdlService/CreateSource" => {
2670 #[allow(non_camel_case_types)]
2671 struct CreateSourceSvc<T: DdlService>(pub Arc<T>);
2672 impl<
2673 T: DdlService,
2674 > tonic::server::UnaryService<super::CreateSourceRequest>
2675 for CreateSourceSvc<T> {
2676 type Response = super::CreateSourceResponse;
2677 type Future = BoxFuture<
2678 tonic::Response<Self::Response>,
2679 tonic::Status,
2680 >;
2681 fn call(
2682 &mut self,
2683 request: tonic::Request<super::CreateSourceRequest>,
2684 ) -> Self::Future {
2685 let inner = Arc::clone(&self.0);
2686 let fut = async move {
2687 <T as DdlService>::create_source(&inner, request).await
2688 };
2689 Box::pin(fut)
2690 }
2691 }
2692 let accept_compression_encodings = self.accept_compression_encodings;
2693 let send_compression_encodings = self.send_compression_encodings;
2694 let max_decoding_message_size = self.max_decoding_message_size;
2695 let max_encoding_message_size = self.max_encoding_message_size;
2696 let inner = self.inner.clone();
2697 let fut = async move {
2698 let method = CreateSourceSvc(inner);
2699 let codec = tonic::codec::ProstCodec::default();
2700 let mut grpc = tonic::server::Grpc::new(codec)
2701 .apply_compression_config(
2702 accept_compression_encodings,
2703 send_compression_encodings,
2704 )
2705 .apply_max_message_size_config(
2706 max_decoding_message_size,
2707 max_encoding_message_size,
2708 );
2709 let res = grpc.unary(method, req).await;
2710 Ok(res)
2711 };
2712 Box::pin(fut)
2713 }
2714 "/ddl_service.DdlService/DropSource" => {
2715 #[allow(non_camel_case_types)]
2716 struct DropSourceSvc<T: DdlService>(pub Arc<T>);
2717 impl<
2718 T: DdlService,
2719 > tonic::server::UnaryService<super::DropSourceRequest>
2720 for DropSourceSvc<T> {
2721 type Response = super::DropSourceResponse;
2722 type Future = BoxFuture<
2723 tonic::Response<Self::Response>,
2724 tonic::Status,
2725 >;
2726 fn call(
2727 &mut self,
2728 request: tonic::Request<super::DropSourceRequest>,
2729 ) -> Self::Future {
2730 let inner = Arc::clone(&self.0);
2731 let fut = async move {
2732 <T as DdlService>::drop_source(&inner, request).await
2733 };
2734 Box::pin(fut)
2735 }
2736 }
2737 let accept_compression_encodings = self.accept_compression_encodings;
2738 let send_compression_encodings = self.send_compression_encodings;
2739 let max_decoding_message_size = self.max_decoding_message_size;
2740 let max_encoding_message_size = self.max_encoding_message_size;
2741 let inner = self.inner.clone();
2742 let fut = async move {
2743 let method = DropSourceSvc(inner);
2744 let codec = tonic::codec::ProstCodec::default();
2745 let mut grpc = tonic::server::Grpc::new(codec)
2746 .apply_compression_config(
2747 accept_compression_encodings,
2748 send_compression_encodings,
2749 )
2750 .apply_max_message_size_config(
2751 max_decoding_message_size,
2752 max_encoding_message_size,
2753 );
2754 let res = grpc.unary(method, req).await;
2755 Ok(res)
2756 };
2757 Box::pin(fut)
2758 }
2759 "/ddl_service.DdlService/CreateSink" => {
2760 #[allow(non_camel_case_types)]
2761 struct CreateSinkSvc<T: DdlService>(pub Arc<T>);
2762 impl<
2763 T: DdlService,
2764 > tonic::server::UnaryService<super::CreateSinkRequest>
2765 for CreateSinkSvc<T> {
2766 type Response = super::CreateSinkResponse;
2767 type Future = BoxFuture<
2768 tonic::Response<Self::Response>,
2769 tonic::Status,
2770 >;
2771 fn call(
2772 &mut self,
2773 request: tonic::Request<super::CreateSinkRequest>,
2774 ) -> Self::Future {
2775 let inner = Arc::clone(&self.0);
2776 let fut = async move {
2777 <T as DdlService>::create_sink(&inner, request).await
2778 };
2779 Box::pin(fut)
2780 }
2781 }
2782 let accept_compression_encodings = self.accept_compression_encodings;
2783 let send_compression_encodings = self.send_compression_encodings;
2784 let max_decoding_message_size = self.max_decoding_message_size;
2785 let max_encoding_message_size = self.max_encoding_message_size;
2786 let inner = self.inner.clone();
2787 let fut = async move {
2788 let method = CreateSinkSvc(inner);
2789 let codec = tonic::codec::ProstCodec::default();
2790 let mut grpc = tonic::server::Grpc::new(codec)
2791 .apply_compression_config(
2792 accept_compression_encodings,
2793 send_compression_encodings,
2794 )
2795 .apply_max_message_size_config(
2796 max_decoding_message_size,
2797 max_encoding_message_size,
2798 );
2799 let res = grpc.unary(method, req).await;
2800 Ok(res)
2801 };
2802 Box::pin(fut)
2803 }
2804 "/ddl_service.DdlService/CreateSubscription" => {
2805 #[allow(non_camel_case_types)]
2806 struct CreateSubscriptionSvc<T: DdlService>(pub Arc<T>);
2807 impl<
2808 T: DdlService,
2809 > tonic::server::UnaryService<super::CreateSubscriptionRequest>
2810 for CreateSubscriptionSvc<T> {
2811 type Response = super::CreateSubscriptionResponse;
2812 type Future = BoxFuture<
2813 tonic::Response<Self::Response>,
2814 tonic::Status,
2815 >;
2816 fn call(
2817 &mut self,
2818 request: tonic::Request<super::CreateSubscriptionRequest>,
2819 ) -> Self::Future {
2820 let inner = Arc::clone(&self.0);
2821 let fut = async move {
2822 <T as DdlService>::create_subscription(&inner, request)
2823 .await
2824 };
2825 Box::pin(fut)
2826 }
2827 }
2828 let accept_compression_encodings = self.accept_compression_encodings;
2829 let send_compression_encodings = self.send_compression_encodings;
2830 let max_decoding_message_size = self.max_decoding_message_size;
2831 let max_encoding_message_size = self.max_encoding_message_size;
2832 let inner = self.inner.clone();
2833 let fut = async move {
2834 let method = CreateSubscriptionSvc(inner);
2835 let codec = tonic::codec::ProstCodec::default();
2836 let mut grpc = tonic::server::Grpc::new(codec)
2837 .apply_compression_config(
2838 accept_compression_encodings,
2839 send_compression_encodings,
2840 )
2841 .apply_max_message_size_config(
2842 max_decoding_message_size,
2843 max_encoding_message_size,
2844 );
2845 let res = grpc.unary(method, req).await;
2846 Ok(res)
2847 };
2848 Box::pin(fut)
2849 }
2850 "/ddl_service.DdlService/DropSink" => {
2851 #[allow(non_camel_case_types)]
2852 struct DropSinkSvc<T: DdlService>(pub Arc<T>);
2853 impl<
2854 T: DdlService,
2855 > tonic::server::UnaryService<super::DropSinkRequest>
2856 for DropSinkSvc<T> {
2857 type Response = super::DropSinkResponse;
2858 type Future = BoxFuture<
2859 tonic::Response<Self::Response>,
2860 tonic::Status,
2861 >;
2862 fn call(
2863 &mut self,
2864 request: tonic::Request<super::DropSinkRequest>,
2865 ) -> Self::Future {
2866 let inner = Arc::clone(&self.0);
2867 let fut = async move {
2868 <T as DdlService>::drop_sink(&inner, request).await
2869 };
2870 Box::pin(fut)
2871 }
2872 }
2873 let accept_compression_encodings = self.accept_compression_encodings;
2874 let send_compression_encodings = self.send_compression_encodings;
2875 let max_decoding_message_size = self.max_decoding_message_size;
2876 let max_encoding_message_size = self.max_encoding_message_size;
2877 let inner = self.inner.clone();
2878 let fut = async move {
2879 let method = DropSinkSvc(inner);
2880 let codec = tonic::codec::ProstCodec::default();
2881 let mut grpc = tonic::server::Grpc::new(codec)
2882 .apply_compression_config(
2883 accept_compression_encodings,
2884 send_compression_encodings,
2885 )
2886 .apply_max_message_size_config(
2887 max_decoding_message_size,
2888 max_encoding_message_size,
2889 );
2890 let res = grpc.unary(method, req).await;
2891 Ok(res)
2892 };
2893 Box::pin(fut)
2894 }
2895 "/ddl_service.DdlService/DropSubscription" => {
2896 #[allow(non_camel_case_types)]
2897 struct DropSubscriptionSvc<T: DdlService>(pub Arc<T>);
2898 impl<
2899 T: DdlService,
2900 > tonic::server::UnaryService<super::DropSubscriptionRequest>
2901 for DropSubscriptionSvc<T> {
2902 type Response = super::DropSubscriptionResponse;
2903 type Future = BoxFuture<
2904 tonic::Response<Self::Response>,
2905 tonic::Status,
2906 >;
2907 fn call(
2908 &mut self,
2909 request: tonic::Request<super::DropSubscriptionRequest>,
2910 ) -> Self::Future {
2911 let inner = Arc::clone(&self.0);
2912 let fut = async move {
2913 <T as DdlService>::drop_subscription(&inner, request).await
2914 };
2915 Box::pin(fut)
2916 }
2917 }
2918 let accept_compression_encodings = self.accept_compression_encodings;
2919 let send_compression_encodings = self.send_compression_encodings;
2920 let max_decoding_message_size = self.max_decoding_message_size;
2921 let max_encoding_message_size = self.max_encoding_message_size;
2922 let inner = self.inner.clone();
2923 let fut = async move {
2924 let method = DropSubscriptionSvc(inner);
2925 let codec = tonic::codec::ProstCodec::default();
2926 let mut grpc = tonic::server::Grpc::new(codec)
2927 .apply_compression_config(
2928 accept_compression_encodings,
2929 send_compression_encodings,
2930 )
2931 .apply_max_message_size_config(
2932 max_decoding_message_size,
2933 max_encoding_message_size,
2934 );
2935 let res = grpc.unary(method, req).await;
2936 Ok(res)
2937 };
2938 Box::pin(fut)
2939 }
2940 "/ddl_service.DdlService/CreateMaterializedView" => {
2941 #[allow(non_camel_case_types)]
2942 struct CreateMaterializedViewSvc<T: DdlService>(pub Arc<T>);
2943 impl<
2944 T: DdlService,
2945 > tonic::server::UnaryService<super::CreateMaterializedViewRequest>
2946 for CreateMaterializedViewSvc<T> {
2947 type Response = super::CreateMaterializedViewResponse;
2948 type Future = BoxFuture<
2949 tonic::Response<Self::Response>,
2950 tonic::Status,
2951 >;
2952 fn call(
2953 &mut self,
2954 request: tonic::Request<super::CreateMaterializedViewRequest>,
2955 ) -> Self::Future {
2956 let inner = Arc::clone(&self.0);
2957 let fut = async move {
2958 <T as DdlService>::create_materialized_view(&inner, request)
2959 .await
2960 };
2961 Box::pin(fut)
2962 }
2963 }
2964 let accept_compression_encodings = self.accept_compression_encodings;
2965 let send_compression_encodings = self.send_compression_encodings;
2966 let max_decoding_message_size = self.max_decoding_message_size;
2967 let max_encoding_message_size = self.max_encoding_message_size;
2968 let inner = self.inner.clone();
2969 let fut = async move {
2970 let method = CreateMaterializedViewSvc(inner);
2971 let codec = tonic::codec::ProstCodec::default();
2972 let mut grpc = tonic::server::Grpc::new(codec)
2973 .apply_compression_config(
2974 accept_compression_encodings,
2975 send_compression_encodings,
2976 )
2977 .apply_max_message_size_config(
2978 max_decoding_message_size,
2979 max_encoding_message_size,
2980 );
2981 let res = grpc.unary(method, req).await;
2982 Ok(res)
2983 };
2984 Box::pin(fut)
2985 }
2986 "/ddl_service.DdlService/DropMaterializedView" => {
2987 #[allow(non_camel_case_types)]
2988 struct DropMaterializedViewSvc<T: DdlService>(pub Arc<T>);
2989 impl<
2990 T: DdlService,
2991 > tonic::server::UnaryService<super::DropMaterializedViewRequest>
2992 for DropMaterializedViewSvc<T> {
2993 type Response = super::DropMaterializedViewResponse;
2994 type Future = BoxFuture<
2995 tonic::Response<Self::Response>,
2996 tonic::Status,
2997 >;
2998 fn call(
2999 &mut self,
3000 request: tonic::Request<super::DropMaterializedViewRequest>,
3001 ) -> Self::Future {
3002 let inner = Arc::clone(&self.0);
3003 let fut = async move {
3004 <T as DdlService>::drop_materialized_view(&inner, request)
3005 .await
3006 };
3007 Box::pin(fut)
3008 }
3009 }
3010 let accept_compression_encodings = self.accept_compression_encodings;
3011 let send_compression_encodings = self.send_compression_encodings;
3012 let max_decoding_message_size = self.max_decoding_message_size;
3013 let max_encoding_message_size = self.max_encoding_message_size;
3014 let inner = self.inner.clone();
3015 let fut = async move {
3016 let method = DropMaterializedViewSvc(inner);
3017 let codec = tonic::codec::ProstCodec::default();
3018 let mut grpc = tonic::server::Grpc::new(codec)
3019 .apply_compression_config(
3020 accept_compression_encodings,
3021 send_compression_encodings,
3022 )
3023 .apply_max_message_size_config(
3024 max_decoding_message_size,
3025 max_encoding_message_size,
3026 );
3027 let res = grpc.unary(method, req).await;
3028 Ok(res)
3029 };
3030 Box::pin(fut)
3031 }
3032 "/ddl_service.DdlService/CreateTable" => {
3033 #[allow(non_camel_case_types)]
3034 struct CreateTableSvc<T: DdlService>(pub Arc<T>);
3035 impl<
3036 T: DdlService,
3037 > tonic::server::UnaryService<super::CreateTableRequest>
3038 for CreateTableSvc<T> {
3039 type Response = super::CreateTableResponse;
3040 type Future = BoxFuture<
3041 tonic::Response<Self::Response>,
3042 tonic::Status,
3043 >;
3044 fn call(
3045 &mut self,
3046 request: tonic::Request<super::CreateTableRequest>,
3047 ) -> Self::Future {
3048 let inner = Arc::clone(&self.0);
3049 let fut = async move {
3050 <T as DdlService>::create_table(&inner, request).await
3051 };
3052 Box::pin(fut)
3053 }
3054 }
3055 let accept_compression_encodings = self.accept_compression_encodings;
3056 let send_compression_encodings = self.send_compression_encodings;
3057 let max_decoding_message_size = self.max_decoding_message_size;
3058 let max_encoding_message_size = self.max_encoding_message_size;
3059 let inner = self.inner.clone();
3060 let fut = async move {
3061 let method = CreateTableSvc(inner);
3062 let codec = tonic::codec::ProstCodec::default();
3063 let mut grpc = tonic::server::Grpc::new(codec)
3064 .apply_compression_config(
3065 accept_compression_encodings,
3066 send_compression_encodings,
3067 )
3068 .apply_max_message_size_config(
3069 max_decoding_message_size,
3070 max_encoding_message_size,
3071 );
3072 let res = grpc.unary(method, req).await;
3073 Ok(res)
3074 };
3075 Box::pin(fut)
3076 }
3077 "/ddl_service.DdlService/CreateSecret" => {
3078 #[allow(non_camel_case_types)]
3079 struct CreateSecretSvc<T: DdlService>(pub Arc<T>);
3080 impl<
3081 T: DdlService,
3082 > tonic::server::UnaryService<super::CreateSecretRequest>
3083 for CreateSecretSvc<T> {
3084 type Response = super::CreateSecretResponse;
3085 type Future = BoxFuture<
3086 tonic::Response<Self::Response>,
3087 tonic::Status,
3088 >;
3089 fn call(
3090 &mut self,
3091 request: tonic::Request<super::CreateSecretRequest>,
3092 ) -> Self::Future {
3093 let inner = Arc::clone(&self.0);
3094 let fut = async move {
3095 <T as DdlService>::create_secret(&inner, request).await
3096 };
3097 Box::pin(fut)
3098 }
3099 }
3100 let accept_compression_encodings = self.accept_compression_encodings;
3101 let send_compression_encodings = self.send_compression_encodings;
3102 let max_decoding_message_size = self.max_decoding_message_size;
3103 let max_encoding_message_size = self.max_encoding_message_size;
3104 let inner = self.inner.clone();
3105 let fut = async move {
3106 let method = CreateSecretSvc(inner);
3107 let codec = tonic::codec::ProstCodec::default();
3108 let mut grpc = tonic::server::Grpc::new(codec)
3109 .apply_compression_config(
3110 accept_compression_encodings,
3111 send_compression_encodings,
3112 )
3113 .apply_max_message_size_config(
3114 max_decoding_message_size,
3115 max_encoding_message_size,
3116 );
3117 let res = grpc.unary(method, req).await;
3118 Ok(res)
3119 };
3120 Box::pin(fut)
3121 }
3122 "/ddl_service.DdlService/DropSecret" => {
3123 #[allow(non_camel_case_types)]
3124 struct DropSecretSvc<T: DdlService>(pub Arc<T>);
3125 impl<
3126 T: DdlService,
3127 > tonic::server::UnaryService<super::DropSecretRequest>
3128 for DropSecretSvc<T> {
3129 type Response = super::DropSecretResponse;
3130 type Future = BoxFuture<
3131 tonic::Response<Self::Response>,
3132 tonic::Status,
3133 >;
3134 fn call(
3135 &mut self,
3136 request: tonic::Request<super::DropSecretRequest>,
3137 ) -> Self::Future {
3138 let inner = Arc::clone(&self.0);
3139 let fut = async move {
3140 <T as DdlService>::drop_secret(&inner, request).await
3141 };
3142 Box::pin(fut)
3143 }
3144 }
3145 let accept_compression_encodings = self.accept_compression_encodings;
3146 let send_compression_encodings = self.send_compression_encodings;
3147 let max_decoding_message_size = self.max_decoding_message_size;
3148 let max_encoding_message_size = self.max_encoding_message_size;
3149 let inner = self.inner.clone();
3150 let fut = async move {
3151 let method = DropSecretSvc(inner);
3152 let codec = tonic::codec::ProstCodec::default();
3153 let mut grpc = tonic::server::Grpc::new(codec)
3154 .apply_compression_config(
3155 accept_compression_encodings,
3156 send_compression_encodings,
3157 )
3158 .apply_max_message_size_config(
3159 max_decoding_message_size,
3160 max_encoding_message_size,
3161 );
3162 let res = grpc.unary(method, req).await;
3163 Ok(res)
3164 };
3165 Box::pin(fut)
3166 }
3167 "/ddl_service.DdlService/AlterSecret" => {
3168 #[allow(non_camel_case_types)]
3169 struct AlterSecretSvc<T: DdlService>(pub Arc<T>);
3170 impl<
3171 T: DdlService,
3172 > tonic::server::UnaryService<super::AlterSecretRequest>
3173 for AlterSecretSvc<T> {
3174 type Response = super::AlterSecretResponse;
3175 type Future = BoxFuture<
3176 tonic::Response<Self::Response>,
3177 tonic::Status,
3178 >;
3179 fn call(
3180 &mut self,
3181 request: tonic::Request<super::AlterSecretRequest>,
3182 ) -> Self::Future {
3183 let inner = Arc::clone(&self.0);
3184 let fut = async move {
3185 <T as DdlService>::alter_secret(&inner, request).await
3186 };
3187 Box::pin(fut)
3188 }
3189 }
3190 let accept_compression_encodings = self.accept_compression_encodings;
3191 let send_compression_encodings = self.send_compression_encodings;
3192 let max_decoding_message_size = self.max_decoding_message_size;
3193 let max_encoding_message_size = self.max_encoding_message_size;
3194 let inner = self.inner.clone();
3195 let fut = async move {
3196 let method = AlterSecretSvc(inner);
3197 let codec = tonic::codec::ProstCodec::default();
3198 let mut grpc = tonic::server::Grpc::new(codec)
3199 .apply_compression_config(
3200 accept_compression_encodings,
3201 send_compression_encodings,
3202 )
3203 .apply_max_message_size_config(
3204 max_decoding_message_size,
3205 max_encoding_message_size,
3206 );
3207 let res = grpc.unary(method, req).await;
3208 Ok(res)
3209 };
3210 Box::pin(fut)
3211 }
3212 "/ddl_service.DdlService/AlterName" => {
3213 #[allow(non_camel_case_types)]
3214 struct AlterNameSvc<T: DdlService>(pub Arc<T>);
3215 impl<
3216 T: DdlService,
3217 > tonic::server::UnaryService<super::AlterNameRequest>
3218 for AlterNameSvc<T> {
3219 type Response = super::AlterNameResponse;
3220 type Future = BoxFuture<
3221 tonic::Response<Self::Response>,
3222 tonic::Status,
3223 >;
3224 fn call(
3225 &mut self,
3226 request: tonic::Request<super::AlterNameRequest>,
3227 ) -> Self::Future {
3228 let inner = Arc::clone(&self.0);
3229 let fut = async move {
3230 <T as DdlService>::alter_name(&inner, request).await
3231 };
3232 Box::pin(fut)
3233 }
3234 }
3235 let accept_compression_encodings = self.accept_compression_encodings;
3236 let send_compression_encodings = self.send_compression_encodings;
3237 let max_decoding_message_size = self.max_decoding_message_size;
3238 let max_encoding_message_size = self.max_encoding_message_size;
3239 let inner = self.inner.clone();
3240 let fut = async move {
3241 let method = AlterNameSvc(inner);
3242 let codec = tonic::codec::ProstCodec::default();
3243 let mut grpc = tonic::server::Grpc::new(codec)
3244 .apply_compression_config(
3245 accept_compression_encodings,
3246 send_compression_encodings,
3247 )
3248 .apply_max_message_size_config(
3249 max_decoding_message_size,
3250 max_encoding_message_size,
3251 );
3252 let res = grpc.unary(method, req).await;
3253 Ok(res)
3254 };
3255 Box::pin(fut)
3256 }
3257 "/ddl_service.DdlService/AlterSource" => {
3258 #[allow(non_camel_case_types)]
3259 struct AlterSourceSvc<T: DdlService>(pub Arc<T>);
3260 impl<
3261 T: DdlService,
3262 > tonic::server::UnaryService<super::AlterSourceRequest>
3263 for AlterSourceSvc<T> {
3264 type Response = super::AlterSourceResponse;
3265 type Future = BoxFuture<
3266 tonic::Response<Self::Response>,
3267 tonic::Status,
3268 >;
3269 fn call(
3270 &mut self,
3271 request: tonic::Request<super::AlterSourceRequest>,
3272 ) -> Self::Future {
3273 let inner = Arc::clone(&self.0);
3274 let fut = async move {
3275 <T as DdlService>::alter_source(&inner, request).await
3276 };
3277 Box::pin(fut)
3278 }
3279 }
3280 let accept_compression_encodings = self.accept_compression_encodings;
3281 let send_compression_encodings = self.send_compression_encodings;
3282 let max_decoding_message_size = self.max_decoding_message_size;
3283 let max_encoding_message_size = self.max_encoding_message_size;
3284 let inner = self.inner.clone();
3285 let fut = async move {
3286 let method = AlterSourceSvc(inner);
3287 let codec = tonic::codec::ProstCodec::default();
3288 let mut grpc = tonic::server::Grpc::new(codec)
3289 .apply_compression_config(
3290 accept_compression_encodings,
3291 send_compression_encodings,
3292 )
3293 .apply_max_message_size_config(
3294 max_decoding_message_size,
3295 max_encoding_message_size,
3296 );
3297 let res = grpc.unary(method, req).await;
3298 Ok(res)
3299 };
3300 Box::pin(fut)
3301 }
3302 "/ddl_service.DdlService/AlterOwner" => {
3303 #[allow(non_camel_case_types)]
3304 struct AlterOwnerSvc<T: DdlService>(pub Arc<T>);
3305 impl<
3306 T: DdlService,
3307 > tonic::server::UnaryService<super::AlterOwnerRequest>
3308 for AlterOwnerSvc<T> {
3309 type Response = super::AlterOwnerResponse;
3310 type Future = BoxFuture<
3311 tonic::Response<Self::Response>,
3312 tonic::Status,
3313 >;
3314 fn call(
3315 &mut self,
3316 request: tonic::Request<super::AlterOwnerRequest>,
3317 ) -> Self::Future {
3318 let inner = Arc::clone(&self.0);
3319 let fut = async move {
3320 <T as DdlService>::alter_owner(&inner, request).await
3321 };
3322 Box::pin(fut)
3323 }
3324 }
3325 let accept_compression_encodings = self.accept_compression_encodings;
3326 let send_compression_encodings = self.send_compression_encodings;
3327 let max_decoding_message_size = self.max_decoding_message_size;
3328 let max_encoding_message_size = self.max_encoding_message_size;
3329 let inner = self.inner.clone();
3330 let fut = async move {
3331 let method = AlterOwnerSvc(inner);
3332 let codec = tonic::codec::ProstCodec::default();
3333 let mut grpc = tonic::server::Grpc::new(codec)
3334 .apply_compression_config(
3335 accept_compression_encodings,
3336 send_compression_encodings,
3337 )
3338 .apply_max_message_size_config(
3339 max_decoding_message_size,
3340 max_encoding_message_size,
3341 );
3342 let res = grpc.unary(method, req).await;
3343 Ok(res)
3344 };
3345 Box::pin(fut)
3346 }
3347 "/ddl_service.DdlService/AlterSetSchema" => {
3348 #[allow(non_camel_case_types)]
3349 struct AlterSetSchemaSvc<T: DdlService>(pub Arc<T>);
3350 impl<
3351 T: DdlService,
3352 > tonic::server::UnaryService<super::AlterSetSchemaRequest>
3353 for AlterSetSchemaSvc<T> {
3354 type Response = super::AlterSetSchemaResponse;
3355 type Future = BoxFuture<
3356 tonic::Response<Self::Response>,
3357 tonic::Status,
3358 >;
3359 fn call(
3360 &mut self,
3361 request: tonic::Request<super::AlterSetSchemaRequest>,
3362 ) -> Self::Future {
3363 let inner = Arc::clone(&self.0);
3364 let fut = async move {
3365 <T as DdlService>::alter_set_schema(&inner, request).await
3366 };
3367 Box::pin(fut)
3368 }
3369 }
3370 let accept_compression_encodings = self.accept_compression_encodings;
3371 let send_compression_encodings = self.send_compression_encodings;
3372 let max_decoding_message_size = self.max_decoding_message_size;
3373 let max_encoding_message_size = self.max_encoding_message_size;
3374 let inner = self.inner.clone();
3375 let fut = async move {
3376 let method = AlterSetSchemaSvc(inner);
3377 let codec = tonic::codec::ProstCodec::default();
3378 let mut grpc = tonic::server::Grpc::new(codec)
3379 .apply_compression_config(
3380 accept_compression_encodings,
3381 send_compression_encodings,
3382 )
3383 .apply_max_message_size_config(
3384 max_decoding_message_size,
3385 max_encoding_message_size,
3386 );
3387 let res = grpc.unary(method, req).await;
3388 Ok(res)
3389 };
3390 Box::pin(fut)
3391 }
3392 "/ddl_service.DdlService/AlterParallelism" => {
3393 #[allow(non_camel_case_types)]
3394 struct AlterParallelismSvc<T: DdlService>(pub Arc<T>);
3395 impl<
3396 T: DdlService,
3397 > tonic::server::UnaryService<super::AlterParallelismRequest>
3398 for AlterParallelismSvc<T> {
3399 type Response = super::AlterParallelismResponse;
3400 type Future = BoxFuture<
3401 tonic::Response<Self::Response>,
3402 tonic::Status,
3403 >;
3404 fn call(
3405 &mut self,
3406 request: tonic::Request<super::AlterParallelismRequest>,
3407 ) -> Self::Future {
3408 let inner = Arc::clone(&self.0);
3409 let fut = async move {
3410 <T as DdlService>::alter_parallelism(&inner, request).await
3411 };
3412 Box::pin(fut)
3413 }
3414 }
3415 let accept_compression_encodings = self.accept_compression_encodings;
3416 let send_compression_encodings = self.send_compression_encodings;
3417 let max_decoding_message_size = self.max_decoding_message_size;
3418 let max_encoding_message_size = self.max_encoding_message_size;
3419 let inner = self.inner.clone();
3420 let fut = async move {
3421 let method = AlterParallelismSvc(inner);
3422 let codec = tonic::codec::ProstCodec::default();
3423 let mut grpc = tonic::server::Grpc::new(codec)
3424 .apply_compression_config(
3425 accept_compression_encodings,
3426 send_compression_encodings,
3427 )
3428 .apply_max_message_size_config(
3429 max_decoding_message_size,
3430 max_encoding_message_size,
3431 );
3432 let res = grpc.unary(method, req).await;
3433 Ok(res)
3434 };
3435 Box::pin(fut)
3436 }
3437 "/ddl_service.DdlService/AlterResourceGroup" => {
3438 #[allow(non_camel_case_types)]
3439 struct AlterResourceGroupSvc<T: DdlService>(pub Arc<T>);
3440 impl<
3441 T: DdlService,
3442 > tonic::server::UnaryService<super::AlterResourceGroupRequest>
3443 for AlterResourceGroupSvc<T> {
3444 type Response = super::AlterResourceGroupResponse;
3445 type Future = BoxFuture<
3446 tonic::Response<Self::Response>,
3447 tonic::Status,
3448 >;
3449 fn call(
3450 &mut self,
3451 request: tonic::Request<super::AlterResourceGroupRequest>,
3452 ) -> Self::Future {
3453 let inner = Arc::clone(&self.0);
3454 let fut = async move {
3455 <T as DdlService>::alter_resource_group(&inner, request)
3456 .await
3457 };
3458 Box::pin(fut)
3459 }
3460 }
3461 let accept_compression_encodings = self.accept_compression_encodings;
3462 let send_compression_encodings = self.send_compression_encodings;
3463 let max_decoding_message_size = self.max_decoding_message_size;
3464 let max_encoding_message_size = self.max_encoding_message_size;
3465 let inner = self.inner.clone();
3466 let fut = async move {
3467 let method = AlterResourceGroupSvc(inner);
3468 let codec = tonic::codec::ProstCodec::default();
3469 let mut grpc = tonic::server::Grpc::new(codec)
3470 .apply_compression_config(
3471 accept_compression_encodings,
3472 send_compression_encodings,
3473 )
3474 .apply_max_message_size_config(
3475 max_decoding_message_size,
3476 max_encoding_message_size,
3477 );
3478 let res = grpc.unary(method, req).await;
3479 Ok(res)
3480 };
3481 Box::pin(fut)
3482 }
3483 "/ddl_service.DdlService/DropTable" => {
3484 #[allow(non_camel_case_types)]
3485 struct DropTableSvc<T: DdlService>(pub Arc<T>);
3486 impl<
3487 T: DdlService,
3488 > tonic::server::UnaryService<super::DropTableRequest>
3489 for DropTableSvc<T> {
3490 type Response = super::DropTableResponse;
3491 type Future = BoxFuture<
3492 tonic::Response<Self::Response>,
3493 tonic::Status,
3494 >;
3495 fn call(
3496 &mut self,
3497 request: tonic::Request<super::DropTableRequest>,
3498 ) -> Self::Future {
3499 let inner = Arc::clone(&self.0);
3500 let fut = async move {
3501 <T as DdlService>::drop_table(&inner, request).await
3502 };
3503 Box::pin(fut)
3504 }
3505 }
3506 let accept_compression_encodings = self.accept_compression_encodings;
3507 let send_compression_encodings = self.send_compression_encodings;
3508 let max_decoding_message_size = self.max_decoding_message_size;
3509 let max_encoding_message_size = self.max_encoding_message_size;
3510 let inner = self.inner.clone();
3511 let fut = async move {
3512 let method = DropTableSvc(inner);
3513 let codec = tonic::codec::ProstCodec::default();
3514 let mut grpc = tonic::server::Grpc::new(codec)
3515 .apply_compression_config(
3516 accept_compression_encodings,
3517 send_compression_encodings,
3518 )
3519 .apply_max_message_size_config(
3520 max_decoding_message_size,
3521 max_encoding_message_size,
3522 );
3523 let res = grpc.unary(method, req).await;
3524 Ok(res)
3525 };
3526 Box::pin(fut)
3527 }
3528 "/ddl_service.DdlService/RisectlListStateTables" => {
3529 #[allow(non_camel_case_types)]
3530 struct RisectlListStateTablesSvc<T: DdlService>(pub Arc<T>);
3531 impl<
3532 T: DdlService,
3533 > tonic::server::UnaryService<super::RisectlListStateTablesRequest>
3534 for RisectlListStateTablesSvc<T> {
3535 type Response = super::RisectlListStateTablesResponse;
3536 type Future = BoxFuture<
3537 tonic::Response<Self::Response>,
3538 tonic::Status,
3539 >;
3540 fn call(
3541 &mut self,
3542 request: tonic::Request<super::RisectlListStateTablesRequest>,
3543 ) -> Self::Future {
3544 let inner = Arc::clone(&self.0);
3545 let fut = async move {
3546 <T as DdlService>::risectl_list_state_tables(
3547 &inner,
3548 request,
3549 )
3550 .await
3551 };
3552 Box::pin(fut)
3553 }
3554 }
3555 let accept_compression_encodings = self.accept_compression_encodings;
3556 let send_compression_encodings = self.send_compression_encodings;
3557 let max_decoding_message_size = self.max_decoding_message_size;
3558 let max_encoding_message_size = self.max_encoding_message_size;
3559 let inner = self.inner.clone();
3560 let fut = async move {
3561 let method = RisectlListStateTablesSvc(inner);
3562 let codec = tonic::codec::ProstCodec::default();
3563 let mut grpc = tonic::server::Grpc::new(codec)
3564 .apply_compression_config(
3565 accept_compression_encodings,
3566 send_compression_encodings,
3567 )
3568 .apply_max_message_size_config(
3569 max_decoding_message_size,
3570 max_encoding_message_size,
3571 );
3572 let res = grpc.unary(method, req).await;
3573 Ok(res)
3574 };
3575 Box::pin(fut)
3576 }
3577 "/ddl_service.DdlService/CreateView" => {
3578 #[allow(non_camel_case_types)]
3579 struct CreateViewSvc<T: DdlService>(pub Arc<T>);
3580 impl<
3581 T: DdlService,
3582 > tonic::server::UnaryService<super::CreateViewRequest>
3583 for CreateViewSvc<T> {
3584 type Response = super::CreateViewResponse;
3585 type Future = BoxFuture<
3586 tonic::Response<Self::Response>,
3587 tonic::Status,
3588 >;
3589 fn call(
3590 &mut self,
3591 request: tonic::Request<super::CreateViewRequest>,
3592 ) -> Self::Future {
3593 let inner = Arc::clone(&self.0);
3594 let fut = async move {
3595 <T as DdlService>::create_view(&inner, request).await
3596 };
3597 Box::pin(fut)
3598 }
3599 }
3600 let accept_compression_encodings = self.accept_compression_encodings;
3601 let send_compression_encodings = self.send_compression_encodings;
3602 let max_decoding_message_size = self.max_decoding_message_size;
3603 let max_encoding_message_size = self.max_encoding_message_size;
3604 let inner = self.inner.clone();
3605 let fut = async move {
3606 let method = CreateViewSvc(inner);
3607 let codec = tonic::codec::ProstCodec::default();
3608 let mut grpc = tonic::server::Grpc::new(codec)
3609 .apply_compression_config(
3610 accept_compression_encodings,
3611 send_compression_encodings,
3612 )
3613 .apply_max_message_size_config(
3614 max_decoding_message_size,
3615 max_encoding_message_size,
3616 );
3617 let res = grpc.unary(method, req).await;
3618 Ok(res)
3619 };
3620 Box::pin(fut)
3621 }
3622 "/ddl_service.DdlService/DropView" => {
3623 #[allow(non_camel_case_types)]
3624 struct DropViewSvc<T: DdlService>(pub Arc<T>);
3625 impl<
3626 T: DdlService,
3627 > tonic::server::UnaryService<super::DropViewRequest>
3628 for DropViewSvc<T> {
3629 type Response = super::DropViewResponse;
3630 type Future = BoxFuture<
3631 tonic::Response<Self::Response>,
3632 tonic::Status,
3633 >;
3634 fn call(
3635 &mut self,
3636 request: tonic::Request<super::DropViewRequest>,
3637 ) -> Self::Future {
3638 let inner = Arc::clone(&self.0);
3639 let fut = async move {
3640 <T as DdlService>::drop_view(&inner, request).await
3641 };
3642 Box::pin(fut)
3643 }
3644 }
3645 let accept_compression_encodings = self.accept_compression_encodings;
3646 let send_compression_encodings = self.send_compression_encodings;
3647 let max_decoding_message_size = self.max_decoding_message_size;
3648 let max_encoding_message_size = self.max_encoding_message_size;
3649 let inner = self.inner.clone();
3650 let fut = async move {
3651 let method = DropViewSvc(inner);
3652 let codec = tonic::codec::ProstCodec::default();
3653 let mut grpc = tonic::server::Grpc::new(codec)
3654 .apply_compression_config(
3655 accept_compression_encodings,
3656 send_compression_encodings,
3657 )
3658 .apply_max_message_size_config(
3659 max_decoding_message_size,
3660 max_encoding_message_size,
3661 );
3662 let res = grpc.unary(method, req).await;
3663 Ok(res)
3664 };
3665 Box::pin(fut)
3666 }
3667 "/ddl_service.DdlService/CreateIndex" => {
3668 #[allow(non_camel_case_types)]
3669 struct CreateIndexSvc<T: DdlService>(pub Arc<T>);
3670 impl<
3671 T: DdlService,
3672 > tonic::server::UnaryService<super::CreateIndexRequest>
3673 for CreateIndexSvc<T> {
3674 type Response = super::CreateIndexResponse;
3675 type Future = BoxFuture<
3676 tonic::Response<Self::Response>,
3677 tonic::Status,
3678 >;
3679 fn call(
3680 &mut self,
3681 request: tonic::Request<super::CreateIndexRequest>,
3682 ) -> Self::Future {
3683 let inner = Arc::clone(&self.0);
3684 let fut = async move {
3685 <T as DdlService>::create_index(&inner, request).await
3686 };
3687 Box::pin(fut)
3688 }
3689 }
3690 let accept_compression_encodings = self.accept_compression_encodings;
3691 let send_compression_encodings = self.send_compression_encodings;
3692 let max_decoding_message_size = self.max_decoding_message_size;
3693 let max_encoding_message_size = self.max_encoding_message_size;
3694 let inner = self.inner.clone();
3695 let fut = async move {
3696 let method = CreateIndexSvc(inner);
3697 let codec = tonic::codec::ProstCodec::default();
3698 let mut grpc = tonic::server::Grpc::new(codec)
3699 .apply_compression_config(
3700 accept_compression_encodings,
3701 send_compression_encodings,
3702 )
3703 .apply_max_message_size_config(
3704 max_decoding_message_size,
3705 max_encoding_message_size,
3706 );
3707 let res = grpc.unary(method, req).await;
3708 Ok(res)
3709 };
3710 Box::pin(fut)
3711 }
3712 "/ddl_service.DdlService/DropIndex" => {
3713 #[allow(non_camel_case_types)]
3714 struct DropIndexSvc<T: DdlService>(pub Arc<T>);
3715 impl<
3716 T: DdlService,
3717 > tonic::server::UnaryService<super::DropIndexRequest>
3718 for DropIndexSvc<T> {
3719 type Response = super::DropIndexResponse;
3720 type Future = BoxFuture<
3721 tonic::Response<Self::Response>,
3722 tonic::Status,
3723 >;
3724 fn call(
3725 &mut self,
3726 request: tonic::Request<super::DropIndexRequest>,
3727 ) -> Self::Future {
3728 let inner = Arc::clone(&self.0);
3729 let fut = async move {
3730 <T as DdlService>::drop_index(&inner, request).await
3731 };
3732 Box::pin(fut)
3733 }
3734 }
3735 let accept_compression_encodings = self.accept_compression_encodings;
3736 let send_compression_encodings = self.send_compression_encodings;
3737 let max_decoding_message_size = self.max_decoding_message_size;
3738 let max_encoding_message_size = self.max_encoding_message_size;
3739 let inner = self.inner.clone();
3740 let fut = async move {
3741 let method = DropIndexSvc(inner);
3742 let codec = tonic::codec::ProstCodec::default();
3743 let mut grpc = tonic::server::Grpc::new(codec)
3744 .apply_compression_config(
3745 accept_compression_encodings,
3746 send_compression_encodings,
3747 )
3748 .apply_max_message_size_config(
3749 max_decoding_message_size,
3750 max_encoding_message_size,
3751 );
3752 let res = grpc.unary(method, req).await;
3753 Ok(res)
3754 };
3755 Box::pin(fut)
3756 }
3757 "/ddl_service.DdlService/CreateFunction" => {
3758 #[allow(non_camel_case_types)]
3759 struct CreateFunctionSvc<T: DdlService>(pub Arc<T>);
3760 impl<
3761 T: DdlService,
3762 > tonic::server::UnaryService<super::CreateFunctionRequest>
3763 for CreateFunctionSvc<T> {
3764 type Response = super::CreateFunctionResponse;
3765 type Future = BoxFuture<
3766 tonic::Response<Self::Response>,
3767 tonic::Status,
3768 >;
3769 fn call(
3770 &mut self,
3771 request: tonic::Request<super::CreateFunctionRequest>,
3772 ) -> Self::Future {
3773 let inner = Arc::clone(&self.0);
3774 let fut = async move {
3775 <T as DdlService>::create_function(&inner, request).await
3776 };
3777 Box::pin(fut)
3778 }
3779 }
3780 let accept_compression_encodings = self.accept_compression_encodings;
3781 let send_compression_encodings = self.send_compression_encodings;
3782 let max_decoding_message_size = self.max_decoding_message_size;
3783 let max_encoding_message_size = self.max_encoding_message_size;
3784 let inner = self.inner.clone();
3785 let fut = async move {
3786 let method = CreateFunctionSvc(inner);
3787 let codec = tonic::codec::ProstCodec::default();
3788 let mut grpc = tonic::server::Grpc::new(codec)
3789 .apply_compression_config(
3790 accept_compression_encodings,
3791 send_compression_encodings,
3792 )
3793 .apply_max_message_size_config(
3794 max_decoding_message_size,
3795 max_encoding_message_size,
3796 );
3797 let res = grpc.unary(method, req).await;
3798 Ok(res)
3799 };
3800 Box::pin(fut)
3801 }
3802 "/ddl_service.DdlService/DropFunction" => {
3803 #[allow(non_camel_case_types)]
3804 struct DropFunctionSvc<T: DdlService>(pub Arc<T>);
3805 impl<
3806 T: DdlService,
3807 > tonic::server::UnaryService<super::DropFunctionRequest>
3808 for DropFunctionSvc<T> {
3809 type Response = super::DropFunctionResponse;
3810 type Future = BoxFuture<
3811 tonic::Response<Self::Response>,
3812 tonic::Status,
3813 >;
3814 fn call(
3815 &mut self,
3816 request: tonic::Request<super::DropFunctionRequest>,
3817 ) -> Self::Future {
3818 let inner = Arc::clone(&self.0);
3819 let fut = async move {
3820 <T as DdlService>::drop_function(&inner, request).await
3821 };
3822 Box::pin(fut)
3823 }
3824 }
3825 let accept_compression_encodings = self.accept_compression_encodings;
3826 let send_compression_encodings = self.send_compression_encodings;
3827 let max_decoding_message_size = self.max_decoding_message_size;
3828 let max_encoding_message_size = self.max_encoding_message_size;
3829 let inner = self.inner.clone();
3830 let fut = async move {
3831 let method = DropFunctionSvc(inner);
3832 let codec = tonic::codec::ProstCodec::default();
3833 let mut grpc = tonic::server::Grpc::new(codec)
3834 .apply_compression_config(
3835 accept_compression_encodings,
3836 send_compression_encodings,
3837 )
3838 .apply_max_message_size_config(
3839 max_decoding_message_size,
3840 max_encoding_message_size,
3841 );
3842 let res = grpc.unary(method, req).await;
3843 Ok(res)
3844 };
3845 Box::pin(fut)
3846 }
3847 "/ddl_service.DdlService/ReplaceJobPlan" => {
3848 #[allow(non_camel_case_types)]
3849 struct ReplaceJobPlanSvc<T: DdlService>(pub Arc<T>);
3850 impl<
3851 T: DdlService,
3852 > tonic::server::UnaryService<super::ReplaceJobPlanRequest>
3853 for ReplaceJobPlanSvc<T> {
3854 type Response = super::ReplaceJobPlanResponse;
3855 type Future = BoxFuture<
3856 tonic::Response<Self::Response>,
3857 tonic::Status,
3858 >;
3859 fn call(
3860 &mut self,
3861 request: tonic::Request<super::ReplaceJobPlanRequest>,
3862 ) -> Self::Future {
3863 let inner = Arc::clone(&self.0);
3864 let fut = async move {
3865 <T as DdlService>::replace_job_plan(&inner, request).await
3866 };
3867 Box::pin(fut)
3868 }
3869 }
3870 let accept_compression_encodings = self.accept_compression_encodings;
3871 let send_compression_encodings = self.send_compression_encodings;
3872 let max_decoding_message_size = self.max_decoding_message_size;
3873 let max_encoding_message_size = self.max_encoding_message_size;
3874 let inner = self.inner.clone();
3875 let fut = async move {
3876 let method = ReplaceJobPlanSvc(inner);
3877 let codec = tonic::codec::ProstCodec::default();
3878 let mut grpc = tonic::server::Grpc::new(codec)
3879 .apply_compression_config(
3880 accept_compression_encodings,
3881 send_compression_encodings,
3882 )
3883 .apply_max_message_size_config(
3884 max_decoding_message_size,
3885 max_encoding_message_size,
3886 );
3887 let res = grpc.unary(method, req).await;
3888 Ok(res)
3889 };
3890 Box::pin(fut)
3891 }
3892 "/ddl_service.DdlService/GetTable" => {
3893 #[allow(non_camel_case_types)]
3894 struct GetTableSvc<T: DdlService>(pub Arc<T>);
3895 impl<
3896 T: DdlService,
3897 > tonic::server::UnaryService<super::GetTableRequest>
3898 for GetTableSvc<T> {
3899 type Response = super::GetTableResponse;
3900 type Future = BoxFuture<
3901 tonic::Response<Self::Response>,
3902 tonic::Status,
3903 >;
3904 fn call(
3905 &mut self,
3906 request: tonic::Request<super::GetTableRequest>,
3907 ) -> Self::Future {
3908 let inner = Arc::clone(&self.0);
3909 let fut = async move {
3910 <T as DdlService>::get_table(&inner, request).await
3911 };
3912 Box::pin(fut)
3913 }
3914 }
3915 let accept_compression_encodings = self.accept_compression_encodings;
3916 let send_compression_encodings = self.send_compression_encodings;
3917 let max_decoding_message_size = self.max_decoding_message_size;
3918 let max_encoding_message_size = self.max_encoding_message_size;
3919 let inner = self.inner.clone();
3920 let fut = async move {
3921 let method = GetTableSvc(inner);
3922 let codec = tonic::codec::ProstCodec::default();
3923 let mut grpc = tonic::server::Grpc::new(codec)
3924 .apply_compression_config(
3925 accept_compression_encodings,
3926 send_compression_encodings,
3927 )
3928 .apply_max_message_size_config(
3929 max_decoding_message_size,
3930 max_encoding_message_size,
3931 );
3932 let res = grpc.unary(method, req).await;
3933 Ok(res)
3934 };
3935 Box::pin(fut)
3936 }
3937 "/ddl_service.DdlService/GetDdlProgress" => {
3938 #[allow(non_camel_case_types)]
3939 struct GetDdlProgressSvc<T: DdlService>(pub Arc<T>);
3940 impl<
3941 T: DdlService,
3942 > tonic::server::UnaryService<super::GetDdlProgressRequest>
3943 for GetDdlProgressSvc<T> {
3944 type Response = super::GetDdlProgressResponse;
3945 type Future = BoxFuture<
3946 tonic::Response<Self::Response>,
3947 tonic::Status,
3948 >;
3949 fn call(
3950 &mut self,
3951 request: tonic::Request<super::GetDdlProgressRequest>,
3952 ) -> Self::Future {
3953 let inner = Arc::clone(&self.0);
3954 let fut = async move {
3955 <T as DdlService>::get_ddl_progress(&inner, request).await
3956 };
3957 Box::pin(fut)
3958 }
3959 }
3960 let accept_compression_encodings = self.accept_compression_encodings;
3961 let send_compression_encodings = self.send_compression_encodings;
3962 let max_decoding_message_size = self.max_decoding_message_size;
3963 let max_encoding_message_size = self.max_encoding_message_size;
3964 let inner = self.inner.clone();
3965 let fut = async move {
3966 let method = GetDdlProgressSvc(inner);
3967 let codec = tonic::codec::ProstCodec::default();
3968 let mut grpc = tonic::server::Grpc::new(codec)
3969 .apply_compression_config(
3970 accept_compression_encodings,
3971 send_compression_encodings,
3972 )
3973 .apply_max_message_size_config(
3974 max_decoding_message_size,
3975 max_encoding_message_size,
3976 );
3977 let res = grpc.unary(method, req).await;
3978 Ok(res)
3979 };
3980 Box::pin(fut)
3981 }
3982 "/ddl_service.DdlService/CreateConnection" => {
3983 #[allow(non_camel_case_types)]
3984 struct CreateConnectionSvc<T: DdlService>(pub Arc<T>);
3985 impl<
3986 T: DdlService,
3987 > tonic::server::UnaryService<super::CreateConnectionRequest>
3988 for CreateConnectionSvc<T> {
3989 type Response = super::CreateConnectionResponse;
3990 type Future = BoxFuture<
3991 tonic::Response<Self::Response>,
3992 tonic::Status,
3993 >;
3994 fn call(
3995 &mut self,
3996 request: tonic::Request<super::CreateConnectionRequest>,
3997 ) -> Self::Future {
3998 let inner = Arc::clone(&self.0);
3999 let fut = async move {
4000 <T as DdlService>::create_connection(&inner, request).await
4001 };
4002 Box::pin(fut)
4003 }
4004 }
4005 let accept_compression_encodings = self.accept_compression_encodings;
4006 let send_compression_encodings = self.send_compression_encodings;
4007 let max_decoding_message_size = self.max_decoding_message_size;
4008 let max_encoding_message_size = self.max_encoding_message_size;
4009 let inner = self.inner.clone();
4010 let fut = async move {
4011 let method = CreateConnectionSvc(inner);
4012 let codec = tonic::codec::ProstCodec::default();
4013 let mut grpc = tonic::server::Grpc::new(codec)
4014 .apply_compression_config(
4015 accept_compression_encodings,
4016 send_compression_encodings,
4017 )
4018 .apply_max_message_size_config(
4019 max_decoding_message_size,
4020 max_encoding_message_size,
4021 );
4022 let res = grpc.unary(method, req).await;
4023 Ok(res)
4024 };
4025 Box::pin(fut)
4026 }
4027 "/ddl_service.DdlService/ListConnections" => {
4028 #[allow(non_camel_case_types)]
4029 struct ListConnectionsSvc<T: DdlService>(pub Arc<T>);
4030 impl<
4031 T: DdlService,
4032 > tonic::server::UnaryService<super::ListConnectionsRequest>
4033 for ListConnectionsSvc<T> {
4034 type Response = super::ListConnectionsResponse;
4035 type Future = BoxFuture<
4036 tonic::Response<Self::Response>,
4037 tonic::Status,
4038 >;
4039 fn call(
4040 &mut self,
4041 request: tonic::Request<super::ListConnectionsRequest>,
4042 ) -> Self::Future {
4043 let inner = Arc::clone(&self.0);
4044 let fut = async move {
4045 <T as DdlService>::list_connections(&inner, request).await
4046 };
4047 Box::pin(fut)
4048 }
4049 }
4050 let accept_compression_encodings = self.accept_compression_encodings;
4051 let send_compression_encodings = self.send_compression_encodings;
4052 let max_decoding_message_size = self.max_decoding_message_size;
4053 let max_encoding_message_size = self.max_encoding_message_size;
4054 let inner = self.inner.clone();
4055 let fut = async move {
4056 let method = ListConnectionsSvc(inner);
4057 let codec = tonic::codec::ProstCodec::default();
4058 let mut grpc = tonic::server::Grpc::new(codec)
4059 .apply_compression_config(
4060 accept_compression_encodings,
4061 send_compression_encodings,
4062 )
4063 .apply_max_message_size_config(
4064 max_decoding_message_size,
4065 max_encoding_message_size,
4066 );
4067 let res = grpc.unary(method, req).await;
4068 Ok(res)
4069 };
4070 Box::pin(fut)
4071 }
4072 "/ddl_service.DdlService/DropConnection" => {
4073 #[allow(non_camel_case_types)]
4074 struct DropConnectionSvc<T: DdlService>(pub Arc<T>);
4075 impl<
4076 T: DdlService,
4077 > tonic::server::UnaryService<super::DropConnectionRequest>
4078 for DropConnectionSvc<T> {
4079 type Response = super::DropConnectionResponse;
4080 type Future = BoxFuture<
4081 tonic::Response<Self::Response>,
4082 tonic::Status,
4083 >;
4084 fn call(
4085 &mut self,
4086 request: tonic::Request<super::DropConnectionRequest>,
4087 ) -> Self::Future {
4088 let inner = Arc::clone(&self.0);
4089 let fut = async move {
4090 <T as DdlService>::drop_connection(&inner, request).await
4091 };
4092 Box::pin(fut)
4093 }
4094 }
4095 let accept_compression_encodings = self.accept_compression_encodings;
4096 let send_compression_encodings = self.send_compression_encodings;
4097 let max_decoding_message_size = self.max_decoding_message_size;
4098 let max_encoding_message_size = self.max_encoding_message_size;
4099 let inner = self.inner.clone();
4100 let fut = async move {
4101 let method = DropConnectionSvc(inner);
4102 let codec = tonic::codec::ProstCodec::default();
4103 let mut grpc = tonic::server::Grpc::new(codec)
4104 .apply_compression_config(
4105 accept_compression_encodings,
4106 send_compression_encodings,
4107 )
4108 .apply_max_message_size_config(
4109 max_decoding_message_size,
4110 max_encoding_message_size,
4111 );
4112 let res = grpc.unary(method, req).await;
4113 Ok(res)
4114 };
4115 Box::pin(fut)
4116 }
4117 "/ddl_service.DdlService/GetTables" => {
4118 #[allow(non_camel_case_types)]
4119 struct GetTablesSvc<T: DdlService>(pub Arc<T>);
4120 impl<
4121 T: DdlService,
4122 > tonic::server::UnaryService<super::GetTablesRequest>
4123 for GetTablesSvc<T> {
4124 type Response = super::GetTablesResponse;
4125 type Future = BoxFuture<
4126 tonic::Response<Self::Response>,
4127 tonic::Status,
4128 >;
4129 fn call(
4130 &mut self,
4131 request: tonic::Request<super::GetTablesRequest>,
4132 ) -> Self::Future {
4133 let inner = Arc::clone(&self.0);
4134 let fut = async move {
4135 <T as DdlService>::get_tables(&inner, request).await
4136 };
4137 Box::pin(fut)
4138 }
4139 }
4140 let accept_compression_encodings = self.accept_compression_encodings;
4141 let send_compression_encodings = self.send_compression_encodings;
4142 let max_decoding_message_size = self.max_decoding_message_size;
4143 let max_encoding_message_size = self.max_encoding_message_size;
4144 let inner = self.inner.clone();
4145 let fut = async move {
4146 let method = GetTablesSvc(inner);
4147 let codec = tonic::codec::ProstCodec::default();
4148 let mut grpc = tonic::server::Grpc::new(codec)
4149 .apply_compression_config(
4150 accept_compression_encodings,
4151 send_compression_encodings,
4152 )
4153 .apply_max_message_size_config(
4154 max_decoding_message_size,
4155 max_encoding_message_size,
4156 );
4157 let res = grpc.unary(method, req).await;
4158 Ok(res)
4159 };
4160 Box::pin(fut)
4161 }
4162 "/ddl_service.DdlService/Wait" => {
4163 #[allow(non_camel_case_types)]
4164 struct WaitSvc<T: DdlService>(pub Arc<T>);
4165 impl<T: DdlService> tonic::server::UnaryService<super::WaitRequest>
4166 for WaitSvc<T> {
4167 type Response = super::WaitResponse;
4168 type Future = BoxFuture<
4169 tonic::Response<Self::Response>,
4170 tonic::Status,
4171 >;
4172 fn call(
4173 &mut self,
4174 request: tonic::Request<super::WaitRequest>,
4175 ) -> Self::Future {
4176 let inner = Arc::clone(&self.0);
4177 let fut = async move {
4178 <T as DdlService>::wait(&inner, request).await
4179 };
4180 Box::pin(fut)
4181 }
4182 }
4183 let accept_compression_encodings = self.accept_compression_encodings;
4184 let send_compression_encodings = self.send_compression_encodings;
4185 let max_decoding_message_size = self.max_decoding_message_size;
4186 let max_encoding_message_size = self.max_encoding_message_size;
4187 let inner = self.inner.clone();
4188 let fut = async move {
4189 let method = WaitSvc(inner);
4190 let codec = tonic::codec::ProstCodec::default();
4191 let mut grpc = tonic::server::Grpc::new(codec)
4192 .apply_compression_config(
4193 accept_compression_encodings,
4194 send_compression_encodings,
4195 )
4196 .apply_max_message_size_config(
4197 max_decoding_message_size,
4198 max_encoding_message_size,
4199 );
4200 let res = grpc.unary(method, req).await;
4201 Ok(res)
4202 };
4203 Box::pin(fut)
4204 }
4205 "/ddl_service.DdlService/CommentOn" => {
4206 #[allow(non_camel_case_types)]
4207 struct CommentOnSvc<T: DdlService>(pub Arc<T>);
4208 impl<
4209 T: DdlService,
4210 > tonic::server::UnaryService<super::CommentOnRequest>
4211 for CommentOnSvc<T> {
4212 type Response = super::CommentOnResponse;
4213 type Future = BoxFuture<
4214 tonic::Response<Self::Response>,
4215 tonic::Status,
4216 >;
4217 fn call(
4218 &mut self,
4219 request: tonic::Request<super::CommentOnRequest>,
4220 ) -> Self::Future {
4221 let inner = Arc::clone(&self.0);
4222 let fut = async move {
4223 <T as DdlService>::comment_on(&inner, request).await
4224 };
4225 Box::pin(fut)
4226 }
4227 }
4228 let accept_compression_encodings = self.accept_compression_encodings;
4229 let send_compression_encodings = self.send_compression_encodings;
4230 let max_decoding_message_size = self.max_decoding_message_size;
4231 let max_encoding_message_size = self.max_encoding_message_size;
4232 let inner = self.inner.clone();
4233 let fut = async move {
4234 let method = CommentOnSvc(inner);
4235 let codec = tonic::codec::ProstCodec::default();
4236 let mut grpc = tonic::server::Grpc::new(codec)
4237 .apply_compression_config(
4238 accept_compression_encodings,
4239 send_compression_encodings,
4240 )
4241 .apply_max_message_size_config(
4242 max_decoding_message_size,
4243 max_encoding_message_size,
4244 );
4245 let res = grpc.unary(method, req).await;
4246 Ok(res)
4247 };
4248 Box::pin(fut)
4249 }
4250 "/ddl_service.DdlService/AutoSchemaChange" => {
4251 #[allow(non_camel_case_types)]
4252 struct AutoSchemaChangeSvc<T: DdlService>(pub Arc<T>);
4253 impl<
4254 T: DdlService,
4255 > tonic::server::UnaryService<super::AutoSchemaChangeRequest>
4256 for AutoSchemaChangeSvc<T> {
4257 type Response = super::AutoSchemaChangeResponse;
4258 type Future = BoxFuture<
4259 tonic::Response<Self::Response>,
4260 tonic::Status,
4261 >;
4262 fn call(
4263 &mut self,
4264 request: tonic::Request<super::AutoSchemaChangeRequest>,
4265 ) -> Self::Future {
4266 let inner = Arc::clone(&self.0);
4267 let fut = async move {
4268 <T as DdlService>::auto_schema_change(&inner, request).await
4269 };
4270 Box::pin(fut)
4271 }
4272 }
4273 let accept_compression_encodings = self.accept_compression_encodings;
4274 let send_compression_encodings = self.send_compression_encodings;
4275 let max_decoding_message_size = self.max_decoding_message_size;
4276 let max_encoding_message_size = self.max_encoding_message_size;
4277 let inner = self.inner.clone();
4278 let fut = async move {
4279 let method = AutoSchemaChangeSvc(inner);
4280 let codec = tonic::codec::ProstCodec::default();
4281 let mut grpc = tonic::server::Grpc::new(codec)
4282 .apply_compression_config(
4283 accept_compression_encodings,
4284 send_compression_encodings,
4285 )
4286 .apply_max_message_size_config(
4287 max_decoding_message_size,
4288 max_encoding_message_size,
4289 );
4290 let res = grpc.unary(method, req).await;
4291 Ok(res)
4292 };
4293 Box::pin(fut)
4294 }
4295 "/ddl_service.DdlService/AlterSwapRename" => {
4296 #[allow(non_camel_case_types)]
4297 struct AlterSwapRenameSvc<T: DdlService>(pub Arc<T>);
4298 impl<
4299 T: DdlService,
4300 > tonic::server::UnaryService<super::AlterSwapRenameRequest>
4301 for AlterSwapRenameSvc<T> {
4302 type Response = super::AlterSwapRenameResponse;
4303 type Future = BoxFuture<
4304 tonic::Response<Self::Response>,
4305 tonic::Status,
4306 >;
4307 fn call(
4308 &mut self,
4309 request: tonic::Request<super::AlterSwapRenameRequest>,
4310 ) -> Self::Future {
4311 let inner = Arc::clone(&self.0);
4312 let fut = async move {
4313 <T as DdlService>::alter_swap_rename(&inner, request).await
4314 };
4315 Box::pin(fut)
4316 }
4317 }
4318 let accept_compression_encodings = self.accept_compression_encodings;
4319 let send_compression_encodings = self.send_compression_encodings;
4320 let max_decoding_message_size = self.max_decoding_message_size;
4321 let max_encoding_message_size = self.max_encoding_message_size;
4322 let inner = self.inner.clone();
4323 let fut = async move {
4324 let method = AlterSwapRenameSvc(inner);
4325 let codec = tonic::codec::ProstCodec::default();
4326 let mut grpc = tonic::server::Grpc::new(codec)
4327 .apply_compression_config(
4328 accept_compression_encodings,
4329 send_compression_encodings,
4330 )
4331 .apply_max_message_size_config(
4332 max_decoding_message_size,
4333 max_encoding_message_size,
4334 );
4335 let res = grpc.unary(method, req).await;
4336 Ok(res)
4337 };
4338 Box::pin(fut)
4339 }
4340 "/ddl_service.DdlService/AlterDatabaseParam" => {
4341 #[allow(non_camel_case_types)]
4342 struct AlterDatabaseParamSvc<T: DdlService>(pub Arc<T>);
4343 impl<
4344 T: DdlService,
4345 > tonic::server::UnaryService<super::AlterDatabaseParamRequest>
4346 for AlterDatabaseParamSvc<T> {
4347 type Response = super::AlterDatabaseParamResponse;
4348 type Future = BoxFuture<
4349 tonic::Response<Self::Response>,
4350 tonic::Status,
4351 >;
4352 fn call(
4353 &mut self,
4354 request: tonic::Request<super::AlterDatabaseParamRequest>,
4355 ) -> Self::Future {
4356 let inner = Arc::clone(&self.0);
4357 let fut = async move {
4358 <T as DdlService>::alter_database_param(&inner, request)
4359 .await
4360 };
4361 Box::pin(fut)
4362 }
4363 }
4364 let accept_compression_encodings = self.accept_compression_encodings;
4365 let send_compression_encodings = self.send_compression_encodings;
4366 let max_decoding_message_size = self.max_decoding_message_size;
4367 let max_encoding_message_size = self.max_encoding_message_size;
4368 let inner = self.inner.clone();
4369 let fut = async move {
4370 let method = AlterDatabaseParamSvc(inner);
4371 let codec = tonic::codec::ProstCodec::default();
4372 let mut grpc = tonic::server::Grpc::new(codec)
4373 .apply_compression_config(
4374 accept_compression_encodings,
4375 send_compression_encodings,
4376 )
4377 .apply_max_message_size_config(
4378 max_decoding_message_size,
4379 max_encoding_message_size,
4380 );
4381 let res = grpc.unary(method, req).await;
4382 Ok(res)
4383 };
4384 Box::pin(fut)
4385 }
4386 _ => {
4387 Box::pin(async move {
4388 let mut response = http::Response::new(empty_body());
4389 let headers = response.headers_mut();
4390 headers
4391 .insert(
4392 tonic::Status::GRPC_STATUS,
4393 (tonic::Code::Unimplemented as i32).into(),
4394 );
4395 headers
4396 .insert(
4397 http::header::CONTENT_TYPE,
4398 tonic::metadata::GRPC_CONTENT_TYPE,
4399 );
4400 Ok(response)
4401 })
4402 }
4403 }
4404 }
4405 }
4406 impl<T> Clone for DdlServiceServer<T> {
4407 fn clone(&self) -> Self {
4408 let inner = self.inner.clone();
4409 Self {
4410 inner,
4411 accept_compression_encodings: self.accept_compression_encodings,
4412 send_compression_encodings: self.send_compression_encodings,
4413 max_decoding_message_size: self.max_decoding_message_size,
4414 max_encoding_message_size: self.max_encoding_message_size,
4415 }
4416 }
4417 }
4418 pub const SERVICE_NAME: &str = "ddl_service.DdlService";
4420 impl<T> tonic::server::NamedService for DdlServiceServer<T> {
4421 const NAME: &'static str = SERVICE_NAME;
4422 }
4423}