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