risingwave_pb/
ddl_service.rs

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