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