risingwave_pb/
ddl_service.rs

1// This file is @generated by prost-build.
2#[derive(prost_helpers::AnyPB)]
3#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
4pub struct WaitVersion {
5    #[prost(uint64, tag = "1")]
6    pub catalog_version: u64,
7    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockVersionId")]
8    pub hummock_version_id: crate::id::HummockVersionId,
9}
10#[derive(prost_helpers::AnyPB)]
11#[derive(Clone, PartialEq, Eq, Hash, ::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, Eq, Hash, ::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, Eq, Hash, ::prost::Message)]
26pub struct DropDatabaseRequest {
27    #[prost(uint32, tag = "1", wrapper = "crate::id::DatabaseId")]
28    pub database_id: crate::id::DatabaseId,
29}
30#[derive(prost_helpers::AnyPB)]
31#[derive(Clone, PartialEq, Eq, Hash, ::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, Eq, Hash, ::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, Eq, Hash, ::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, Eq, Hash, ::prost::Message)]
54pub struct DropSchemaRequest {
55    #[prost(uint32, tag = "1", wrapper = "crate::id::SchemaId")]
56    pub schema_id: crate::id::SchemaId,
57    #[prost(bool, tag = "2")]
58    pub cascade: bool,
59}
60#[derive(prost_helpers::AnyPB)]
61#[derive(Clone, PartialEq, Eq, Hash, ::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, Eq, Hash, ::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, Eq, Hash, ::prost::Message)]
88pub struct DropSourceRequest {
89    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
90    pub source_id: crate::id::SourceId,
91    #[prost(bool, tag = "2")]
92    pub cascade: bool,
93}
94#[derive(prost_helpers::AnyPB)]
95#[derive(Clone, PartialEq, Eq, Hash, ::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, Eq, Hash, ::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/// Reset CDC source offset to latest (for handling expired binlog/oplog)
119#[derive(prost_helpers::AnyPB)]
120#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
121pub struct ResetSourceRequest {
122    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
123    pub source_id: crate::id::SourceId,
124}
125#[derive(prost_helpers::AnyPB)]
126#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
127pub struct ResetSourceResponse {
128    #[prost(message, optional, tag = "1")]
129    pub status: ::core::option::Option<super::common::Status>,
130    #[prost(message, optional, tag = "2")]
131    pub version: ::core::option::Option<WaitVersion>,
132}
133#[derive(prost_helpers::AnyPB)]
134#[derive(Clone, PartialEq, ::prost::Message)]
135pub struct CreateSinkRequest {
136    #[prost(message, optional, tag = "1")]
137    pub sink: ::core::option::Option<super::catalog::Sink>,
138    #[prost(message, optional, tag = "2")]
139    pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
140    /// The list of object IDs that this sink depends on.
141    #[prost(uint32, repeated, tag = "4", wrapper = "crate::id::ObjectId")]
142    pub dependencies: ::prost::alloc::vec::Vec<crate::id::ObjectId>,
143    #[prost(bool, tag = "5")]
144    pub if_not_exists: bool,
145    #[prost(message, optional, tag = "6")]
146    pub resource_type: ::core::option::Option<StreamingJobResourceType>,
147    #[prost(uint64, optional, tag = "7")]
148    pub since_timestamp_epoch: ::core::option::Option<u64>,
149}
150#[derive(prost_helpers::AnyPB)]
151#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
152pub struct CreateSinkResponse {
153    #[prost(message, optional, tag = "1")]
154    pub status: ::core::option::Option<super::common::Status>,
155    #[prost(message, optional, tag = "2")]
156    pub version: ::core::option::Option<WaitVersion>,
157}
158#[derive(prost_helpers::AnyPB)]
159#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
160pub struct DropSinkRequest {
161    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
162    pub sink_id: crate::id::SinkId,
163    #[prost(bool, tag = "2")]
164    pub cascade: bool,
165}
166#[derive(prost_helpers::AnyPB)]
167#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
168pub struct DropSinkResponse {
169    #[prost(message, optional, tag = "1")]
170    pub status: ::core::option::Option<super::common::Status>,
171    #[prost(message, optional, tag = "2")]
172    pub version: ::core::option::Option<WaitVersion>,
173}
174#[derive(prost_helpers::AnyPB)]
175#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
176pub struct CreateSubscriptionRequest {
177    #[prost(message, optional, tag = "1")]
178    pub subscription: ::core::option::Option<super::catalog::Subscription>,
179}
180#[derive(prost_helpers::AnyPB)]
181#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
182pub struct CreateSubscriptionResponse {
183    #[prost(message, optional, tag = "1")]
184    pub status: ::core::option::Option<super::common::Status>,
185    #[prost(message, optional, tag = "2")]
186    pub version: ::core::option::Option<WaitVersion>,
187}
188#[derive(prost_helpers::AnyPB)]
189#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
190pub struct DropSubscriptionRequest {
191    #[prost(uint32, tag = "1", wrapper = "crate::id::SubscriptionId")]
192    pub subscription_id: crate::id::SubscriptionId,
193    #[prost(bool, tag = "2")]
194    pub cascade: bool,
195}
196#[derive(prost_helpers::AnyPB)]
197#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
198pub struct DropSubscriptionResponse {
199    #[prost(message, optional, tag = "1")]
200    pub status: ::core::option::Option<super::common::Status>,
201    #[prost(message, optional, tag = "2")]
202    pub version: ::core::option::Option<WaitVersion>,
203}
204/// If SERVERLESS, the materialized view should be created using serverless backfill
205/// For that the controller will create a new compute node, which does backfilling and then is deleted.
206/// May alleviate pressure on the cluster during backfill process.
207#[derive(prost_helpers::AnyPB)]
208#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
209pub struct StreamingJobResourceType {
210    #[prost(oneof = "streaming_job_resource_type::ResourceType", tags = "1, 2, 3")]
211    pub resource_type: ::core::option::Option<streaming_job_resource_type::ResourceType>,
212}
213/// Nested message and enum types in `StreamingJobResourceType`.
214pub mod streaming_job_resource_type {
215    #[derive(prost_helpers::AnyPB)]
216    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
217    pub enum ResourceType {
218        #[prost(bool, tag = "1")]
219        Regular(bool),
220        /// The specific resource group to use for the streaming job. If not set, the database resource group is used.
221        #[prost(string, tag = "2")]
222        SpecificResourceGroup(::prost::alloc::string::String),
223        #[prost(bool, tag = "3")]
224        ServerlessBackfill(bool),
225    }
226}
227#[derive(prost_helpers::AnyPB)]
228#[derive(Clone, PartialEq, ::prost::Message)]
229pub struct CreateMaterializedViewRequest {
230    #[prost(message, optional, tag = "1")]
231    pub materialized_view: ::core::option::Option<super::catalog::Table>,
232    #[prost(message, optional, tag = "2")]
233    pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
234    #[prost(message, optional, tag = "3")]
235    pub resource_type: ::core::option::Option<StreamingJobResourceType>,
236    /// The list of object IDs that this materialized view depends on.
237    #[prost(uint32, repeated, tag = "4", wrapper = "crate::id::ObjectId")]
238    pub dependencies: ::prost::alloc::vec::Vec<crate::id::ObjectId>,
239    #[prost(bool, tag = "6")]
240    pub if_not_exists: bool,
241    #[prost(uint64, optional, tag = "7")]
242    pub refresh_interval_sec: ::core::option::Option<u64>,
243}
244#[derive(prost_helpers::AnyPB)]
245#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
246pub struct CreateMaterializedViewResponse {
247    #[prost(message, optional, tag = "1")]
248    pub status: ::core::option::Option<super::common::Status>,
249    #[prost(message, optional, tag = "2")]
250    pub version: ::core::option::Option<WaitVersion>,
251}
252#[derive(prost_helpers::AnyPB)]
253#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
254pub struct DropMaterializedViewRequest {
255    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
256    pub table_id: crate::id::TableId,
257    #[prost(bool, tag = "2")]
258    pub cascade: bool,
259}
260#[derive(prost_helpers::AnyPB)]
261#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
262pub struct DropMaterializedViewResponse {
263    #[prost(message, optional, tag = "1")]
264    pub status: ::core::option::Option<super::common::Status>,
265    #[prost(message, optional, tag = "2")]
266    pub version: ::core::option::Option<WaitVersion>,
267}
268#[derive(prost_helpers::AnyPB)]
269#[derive(Clone, PartialEq, ::prost::Message)]
270pub struct CreateViewRequest {
271    #[prost(message, optional, tag = "1")]
272    pub view: ::core::option::Option<super::catalog::View>,
273    /// The list of object IDs that this view depends on.
274    #[prost(uint32, repeated, tag = "2", wrapper = "crate::id::ObjectId")]
275    pub dependencies: ::prost::alloc::vec::Vec<crate::id::ObjectId>,
276}
277#[derive(prost_helpers::AnyPB)]
278#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
279pub struct CreateViewResponse {
280    #[prost(message, optional, tag = "1")]
281    pub status: ::core::option::Option<super::common::Status>,
282    #[prost(message, optional, tag = "2")]
283    pub version: ::core::option::Option<WaitVersion>,
284}
285#[derive(prost_helpers::AnyPB)]
286#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
287pub struct DropViewRequest {
288    #[prost(uint32, tag = "1", wrapper = "crate::id::ViewId")]
289    pub view_id: crate::id::ViewId,
290    #[prost(bool, tag = "2")]
291    pub cascade: bool,
292}
293#[derive(prost_helpers::AnyPB)]
294#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
295pub struct DropViewResponse {
296    #[prost(message, optional, tag = "1")]
297    pub status: ::core::option::Option<super::common::Status>,
298    #[prost(message, optional, tag = "2")]
299    pub version: ::core::option::Option<WaitVersion>,
300}
301#[derive(prost_helpers::AnyPB)]
302#[derive(Clone, PartialEq, ::prost::Message)]
303pub struct CreateTableRequest {
304    /// An optional field and will be `Some` for tables with an external connector. If so, the table
305    /// will subscribe to the changes of the external connector and materialize the data.
306    #[prost(message, optional, tag = "1")]
307    pub source: ::core::option::Option<super::catalog::Source>,
308    #[prost(message, optional, tag = "2")]
309    pub materialized_view: ::core::option::Option<super::catalog::Table>,
310    #[prost(message, optional, tag = "3")]
311    pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
312    #[prost(enumeration = "TableJobType", tag = "4")]
313    pub job_type: i32,
314    #[prost(bool, tag = "5")]
315    pub if_not_exists: bool,
316    /// The list of object IDs that this table depends on, currently only used for `SHARED_CDC_SOURCE`.
317    #[prost(uint32, repeated, tag = "6", wrapper = "crate::id::ObjectId")]
318    pub dependencies: ::prost::alloc::vec::Vec<crate::id::ObjectId>,
319}
320#[derive(prost_helpers::AnyPB)]
321#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
322pub struct CreateTableResponse {
323    #[prost(message, optional, tag = "1")]
324    pub status: ::core::option::Option<super::common::Status>,
325    #[prost(message, optional, tag = "2")]
326    pub version: ::core::option::Option<WaitVersion>,
327}
328#[derive(prost_helpers::AnyPB)]
329#[derive(Clone, PartialEq, ::prost::Message)]
330pub struct CreateIcebergTableRequest {
331    #[prost(message, optional, tag = "1")]
332    pub table_info: ::core::option::Option<create_iceberg_table_request::TableJobInfo>,
333    #[prost(message, optional, tag = "2")]
334    pub sink_info: ::core::option::Option<create_iceberg_table_request::SinkJobInfo>,
335    #[prost(message, optional, tag = "3")]
336    pub iceberg_source: ::core::option::Option<super::catalog::Source>,
337    #[prost(bool, tag = "5")]
338    pub if_not_exists: bool,
339}
340/// Nested message and enum types in `CreateIcebergTableRequest`.
341pub mod create_iceberg_table_request {
342    #[derive(prost_helpers::AnyPB)]
343    #[derive(Clone, PartialEq, ::prost::Message)]
344    pub struct TableJobInfo {
345        #[prost(message, optional, tag = "1")]
346        pub source: ::core::option::Option<super::super::catalog::Source>,
347        #[prost(message, optional, tag = "2")]
348        pub table: ::core::option::Option<super::super::catalog::Table>,
349        #[prost(message, optional, tag = "3")]
350        pub fragment_graph: ::core::option::Option<
351            super::super::stream_plan::StreamFragmentGraph,
352        >,
353        #[prost(enumeration = "super::TableJobType", tag = "4")]
354        pub job_type: i32,
355    }
356    #[derive(prost_helpers::AnyPB)]
357    #[derive(Clone, PartialEq, ::prost::Message)]
358    pub struct SinkJobInfo {
359        #[prost(message, optional, tag = "1")]
360        pub sink: ::core::option::Option<super::super::catalog::Sink>,
361        #[prost(message, optional, tag = "2")]
362        pub fragment_graph: ::core::option::Option<
363            super::super::stream_plan::StreamFragmentGraph,
364        >,
365    }
366}
367#[derive(prost_helpers::AnyPB)]
368#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
369pub struct CreateIcebergTableResponse {
370    #[prost(message, optional, tag = "1")]
371    pub status: ::core::option::Option<super::common::Status>,
372    #[prost(message, optional, tag = "2")]
373    pub version: ::core::option::Option<WaitVersion>,
374}
375#[derive(prost_helpers::AnyPB)]
376#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
377pub struct AlterNameRequest {
378    #[prost(string, tag = "20")]
379    pub new_name: ::prost::alloc::string::String,
380    #[prost(oneof = "alter_name_request::Object", tags = "1, 2, 3, 4, 5, 6, 7, 8")]
381    pub object: ::core::option::Option<alter_name_request::Object>,
382}
383/// Nested message and enum types in `AlterNameRequest`.
384pub mod alter_name_request {
385    #[derive(prost_helpers::AnyPB)]
386    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
387    pub enum Object {
388        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
389        TableId(crate::id::TableId),
390        #[prost(uint32, tag = "2", wrapper = "crate::id::ViewId")]
391        ViewId(crate::id::ViewId),
392        #[prost(uint32, tag = "3", wrapper = "crate::id::IndexId")]
393        IndexId(crate::id::IndexId),
394        #[prost(uint32, tag = "4", wrapper = "crate::id::SinkId")]
395        SinkId(crate::id::SinkId),
396        #[prost(uint32, tag = "5", wrapper = "crate::id::SourceId")]
397        SourceId(crate::id::SourceId),
398        #[prost(uint32, tag = "6", wrapper = "crate::id::SchemaId")]
399        SchemaId(crate::id::SchemaId),
400        #[prost(uint32, tag = "7", wrapper = "crate::id::DatabaseId")]
401        DatabaseId(crate::id::DatabaseId),
402        #[prost(uint32, tag = "8", wrapper = "crate::id::SubscriptionId")]
403        SubscriptionId(crate::id::SubscriptionId),
404    }
405}
406#[derive(prost_helpers::AnyPB)]
407#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
408pub struct AlterNameResponse {
409    #[prost(message, optional, tag = "1")]
410    pub status: ::core::option::Option<super::common::Status>,
411    #[prost(message, optional, tag = "2")]
412    pub version: ::core::option::Option<WaitVersion>,
413}
414#[derive(prost_helpers::AnyPB)]
415#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
416pub struct AlterOwnerRequest {
417    #[prost(uint32, tag = "20", wrapper = "crate::id::UserId")]
418    pub owner_id: crate::id::UserId,
419    #[prost(
420        oneof = "alter_owner_request::Object",
421        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10"
422    )]
423    pub object: ::core::option::Option<alter_owner_request::Object>,
424}
425/// Nested message and enum types in `AlterOwnerRequest`.
426pub mod alter_owner_request {
427    #[derive(prost_helpers::AnyPB)]
428    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
429    pub enum Object {
430        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
431        TableId(crate::id::TableId),
432        #[prost(uint32, tag = "2", wrapper = "crate::id::ViewId")]
433        ViewId(crate::id::ViewId),
434        #[prost(uint32, tag = "3", wrapper = "crate::id::SourceId")]
435        SourceId(crate::id::SourceId),
436        #[prost(uint32, tag = "4", wrapper = "crate::id::SinkId")]
437        SinkId(crate::id::SinkId),
438        #[prost(uint32, tag = "5", wrapper = "crate::id::SchemaId")]
439        SchemaId(crate::id::SchemaId),
440        #[prost(uint32, tag = "6", wrapper = "crate::id::DatabaseId")]
441        DatabaseId(crate::id::DatabaseId),
442        #[prost(uint32, tag = "7", wrapper = "crate::id::SubscriptionId")]
443        SubscriptionId(crate::id::SubscriptionId),
444        #[prost(uint32, tag = "8", wrapper = "crate::id::ConnectionId")]
445        ConnectionId(crate::id::ConnectionId),
446        #[prost(uint32, tag = "9", wrapper = "crate::id::SecretId")]
447        SecretId(crate::id::SecretId),
448        #[prost(uint32, tag = "10", wrapper = "crate::id::FunctionId")]
449        FunctionId(crate::id::FunctionId),
450    }
451}
452#[derive(prost_helpers::AnyPB)]
453#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
454pub struct AlterSetSchemaRequest {
455    #[prost(uint32, tag = "20", wrapper = "crate::id::SchemaId")]
456    pub new_schema_id: crate::id::SchemaId,
457    #[prost(oneof = "alter_set_schema_request::Object", tags = "1, 2, 3, 4, 5, 6, 7")]
458    pub object: ::core::option::Option<alter_set_schema_request::Object>,
459}
460/// Nested message and enum types in `AlterSetSchemaRequest`.
461pub mod alter_set_schema_request {
462    #[derive(prost_helpers::AnyPB)]
463    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
464    pub enum Object {
465        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
466        TableId(crate::id::TableId),
467        #[prost(uint32, tag = "2", wrapper = "crate::id::ViewId")]
468        ViewId(crate::id::ViewId),
469        #[prost(uint32, tag = "3", wrapper = "crate::id::SourceId")]
470        SourceId(crate::id::SourceId),
471        #[prost(uint32, tag = "4", wrapper = "crate::id::SinkId")]
472        SinkId(crate::id::SinkId),
473        #[prost(uint32, tag = "5", wrapper = "crate::id::FunctionId")]
474        FunctionId(crate::id::FunctionId),
475        #[prost(uint32, tag = "6", wrapper = "crate::id::ConnectionId")]
476        ConnectionId(crate::id::ConnectionId),
477        #[prost(uint32, tag = "7", wrapper = "crate::id::SubscriptionId")]
478        SubscriptionId(crate::id::SubscriptionId),
479    }
480}
481#[derive(prost_helpers::AnyPB)]
482#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
483pub struct AlterSetSchemaResponse {
484    #[prost(message, optional, tag = "1")]
485    pub status: ::core::option::Option<super::common::Status>,
486    #[prost(message, optional, tag = "2")]
487    pub version: ::core::option::Option<WaitVersion>,
488}
489#[derive(prost_helpers::AnyPB)]
490#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
491pub struct AlterParallelismRequest {
492    /// job id
493    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
494    pub table_id: crate::id::JobId,
495    #[prost(message, optional, tag = "2")]
496    pub parallelism: ::core::option::Option<super::meta::TableParallelism>,
497    #[prost(bool, tag = "3")]
498    pub deferred: bool,
499    #[prost(string, optional, tag = "4")]
500    pub adaptive_parallelism_strategy: ::core::option::Option<
501        ::prost::alloc::string::String,
502    >,
503}
504#[derive(prost_helpers::AnyPB)]
505#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
506pub struct AlterParallelismResponse {}
507#[derive(prost_helpers::AnyPB)]
508#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
509pub struct AlterBackfillParallelismRequest {
510    /// job id
511    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
512    pub table_id: crate::id::JobId,
513    /// When `parallelism` is `None`, it indicates resetting to no backfill override.
514    #[prost(message, optional, tag = "2")]
515    pub parallelism: ::core::option::Option<super::meta::TableParallelism>,
516    #[prost(bool, tag = "3")]
517    pub deferred: bool,
518    #[prost(string, optional, tag = "4")]
519    pub adaptive_parallelism_strategy: ::core::option::Option<
520        ::prost::alloc::string::String,
521    >,
522}
523#[derive(prost_helpers::AnyPB)]
524#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
525pub struct AlterBackfillParallelismResponse {}
526#[derive(prost_helpers::AnyPB)]
527#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
528pub struct AlterFragmentParallelismRequest {
529    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::FragmentId")]
530    pub fragment_ids: ::prost::alloc::vec::Vec<crate::id::FragmentId>,
531    /// When `parallelism` is `None`, it indicates resetting to the job's parallelism.
532    #[prost(message, optional, tag = "2")]
533    pub parallelism: ::core::option::Option<super::meta::TableParallelism>,
534}
535#[derive(prost_helpers::AnyPB)]
536#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
537pub struct AlterFragmentParallelismResponse {}
538#[derive(prost_helpers::AnyPB)]
539#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
540pub struct AlterCdcTableBackfillParallelismRequest {
541    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
542    pub table_id: crate::id::JobId,
543    #[prost(message, optional, tag = "2")]
544    pub parallelism: ::core::option::Option<super::meta::TableParallelism>,
545}
546#[derive(prost_helpers::AnyPB)]
547#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
548pub struct AlterCdcTableBackfillParallelismResponse {}
549#[derive(prost_helpers::AnyPB)]
550#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
551pub struct AlterResourceGroupRequest {
552    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
553    pub job_id: crate::id::JobId,
554    #[prost(string, optional, tag = "2")]
555    pub resource_group: ::core::option::Option<::prost::alloc::string::String>,
556    #[prost(bool, tag = "3")]
557    pub deferred: bool,
558}
559#[derive(prost_helpers::AnyPB)]
560#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
561pub struct AlterResourceGroupResponse {}
562#[derive(prost_helpers::AnyPB)]
563#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
564pub struct AlterDatabaseResourceGroupRequest {
565    #[prost(uint32, tag = "1", wrapper = "crate::id::DatabaseId")]
566    pub database_id: crate::id::DatabaseId,
567    #[prost(string, optional, tag = "2")]
568    pub resource_group: ::core::option::Option<::prost::alloc::string::String>,
569    #[prost(bool, tag = "3")]
570    pub deferred: bool,
571}
572#[derive(prost_helpers::AnyPB)]
573#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
574pub struct AlterDatabaseResourceGroupResponse {
575    #[prost(message, optional, tag = "1")]
576    pub status: ::core::option::Option<super::common::Status>,
577    #[prost(message, optional, tag = "2")]
578    pub version: ::core::option::Option<WaitVersion>,
579}
580#[derive(prost_helpers::AnyPB)]
581#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
582pub struct AlterOwnerResponse {
583    #[prost(message, optional, tag = "1")]
584    pub status: ::core::option::Option<super::common::Status>,
585    #[prost(message, optional, tag = "2")]
586    pub version: ::core::option::Option<WaitVersion>,
587}
588#[derive(prost_helpers::AnyPB)]
589#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
590pub struct AlterSubscriptionRetentionRequest {
591    #[prost(uint32, tag = "1", wrapper = "crate::id::SubscriptionId")]
592    pub subscription_id: crate::id::SubscriptionId,
593    #[prost(uint64, tag = "2")]
594    pub retention_seconds: u64,
595    #[prost(string, tag = "3")]
596    pub definition: ::prost::alloc::string::String,
597}
598#[derive(prost_helpers::AnyPB)]
599#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
600pub struct AlterSubscriptionRetentionResponse {
601    #[prost(message, optional, tag = "1")]
602    pub status: ::core::option::Option<super::common::Status>,
603    #[prost(message, optional, tag = "2")]
604    pub version: ::core::option::Option<WaitVersion>,
605}
606#[derive(prost_helpers::AnyPB)]
607#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
608pub struct AlterSwapRenameRequest {
609    #[prost(oneof = "alter_swap_rename_request::Object", tags = "1, 2, 3, 4, 5, 6")]
610    pub object: ::core::option::Option<alter_swap_rename_request::Object>,
611}
612/// Nested message and enum types in `AlterSwapRenameRequest`.
613pub mod alter_swap_rename_request {
614    #[derive(prost_helpers::AnyPB)]
615    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
616    pub struct ObjectNameSwapPair {
617        #[prost(uint32, tag = "1", wrapper = "crate::id::ObjectId")]
618        pub src_object_id: crate::id::ObjectId,
619        #[prost(uint32, tag = "2", wrapper = "crate::id::ObjectId")]
620        pub dst_object_id: crate::id::ObjectId,
621    }
622    #[derive(prost_helpers::AnyPB)]
623    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
624    pub enum Object {
625        #[prost(message, tag = "1")]
626        Schema(ObjectNameSwapPair),
627        #[prost(message, tag = "2")]
628        Table(ObjectNameSwapPair),
629        #[prost(message, tag = "3")]
630        View(ObjectNameSwapPair),
631        #[prost(message, tag = "4")]
632        Source(ObjectNameSwapPair),
633        #[prost(message, tag = "5")]
634        Sink(ObjectNameSwapPair),
635        #[prost(message, tag = "6")]
636        Subscription(ObjectNameSwapPair),
637    }
638}
639#[derive(prost_helpers::AnyPB)]
640#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
641pub struct AlterSwapRenameResponse {
642    #[prost(message, optional, tag = "1")]
643    pub status: ::core::option::Option<super::common::Status>,
644    #[prost(message, optional, tag = "2")]
645    pub version: ::core::option::Option<WaitVersion>,
646}
647#[derive(prost_helpers::AnyPB)]
648#[derive(Clone, PartialEq, ::prost::Message)]
649pub struct CreateFunctionRequest {
650    #[prost(message, optional, tag = "1")]
651    pub function: ::core::option::Option<super::catalog::Function>,
652}
653#[derive(prost_helpers::AnyPB)]
654#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
655pub struct CreateFunctionResponse {
656    #[prost(message, optional, tag = "1")]
657    pub status: ::core::option::Option<super::common::Status>,
658    #[prost(message, optional, tag = "2")]
659    pub version: ::core::option::Option<WaitVersion>,
660}
661#[derive(prost_helpers::AnyPB)]
662#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
663pub struct DropFunctionRequest {
664    #[prost(uint32, tag = "1", wrapper = "crate::id::FunctionId")]
665    pub function_id: crate::id::FunctionId,
666    #[prost(bool, tag = "2")]
667    pub cascade: bool,
668}
669#[derive(prost_helpers::AnyPB)]
670#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
671pub struct DropFunctionResponse {
672    #[prost(message, optional, tag = "1")]
673    pub status: ::core::option::Option<super::common::Status>,
674    #[prost(message, optional, tag = "2")]
675    pub version: ::core::option::Option<WaitVersion>,
676}
677#[derive(prost_helpers::AnyPB)]
678#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
679pub struct DropTableRequest {
680    #[prost(uint32, tag = "2", wrapper = "crate::id::TableId")]
681    pub table_id: crate::id::TableId,
682    #[prost(bool, tag = "3")]
683    pub cascade: bool,
684    #[prost(oneof = "drop_table_request::SourceId", tags = "1")]
685    pub source_id: ::core::option::Option<drop_table_request::SourceId>,
686}
687/// Nested message and enum types in `DropTableRequest`.
688pub mod drop_table_request {
689    #[derive(prost_helpers::AnyPB)]
690    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
691    pub enum SourceId {
692        #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
693        Id(crate::id::SourceId),
694    }
695}
696#[derive(prost_helpers::AnyPB)]
697#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
698pub struct DropTableResponse {
699    #[prost(message, optional, tag = "1")]
700    pub status: ::core::option::Option<super::common::Status>,
701    #[prost(message, optional, tag = "2")]
702    pub version: ::core::option::Option<WaitVersion>,
703}
704/// Used by risectl (and in the future, dashboard)
705#[derive(prost_helpers::AnyPB)]
706#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
707pub struct RisectlListStateTablesRequest {}
708/// Used by risectl (and in the future, dashboard)
709#[derive(prost_helpers::AnyPB)]
710#[derive(Clone, PartialEq, ::prost::Message)]
711pub struct RisectlListStateTablesResponse {
712    #[prost(message, repeated, tag = "1")]
713    pub tables: ::prost::alloc::vec::Vec<super::catalog::Table>,
714}
715/// Used by risectl
716#[derive(prost_helpers::AnyPB)]
717#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
718pub struct RisectlResumeBackfillRequest {
719    #[prost(oneof = "risectl_resume_backfill_request::Target", tags = "1, 2")]
720    pub target: ::core::option::Option<risectl_resume_backfill_request::Target>,
721}
722/// Nested message and enum types in `RisectlResumeBackfillRequest`.
723pub mod risectl_resume_backfill_request {
724    #[derive(prost_helpers::AnyPB)]
725    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
726    pub enum Target {
727        #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
728        JobId(crate::id::JobId),
729        #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
730        FragmentId(crate::id::FragmentId),
731    }
732}
733/// Used by risectl
734#[derive(prost_helpers::AnyPB)]
735#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
736pub struct RisectlResumeBackfillResponse {}
737#[derive(prost_helpers::AnyPB)]
738#[derive(Clone, PartialEq, ::prost::Message)]
739pub struct CreateIndexRequest {
740    #[prost(message, optional, tag = "1")]
741    pub index: ::core::option::Option<super::catalog::Index>,
742    #[prost(message, optional, tag = "2")]
743    pub index_table: ::core::option::Option<super::catalog::Table>,
744    #[prost(message, optional, tag = "3")]
745    pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
746    #[prost(bool, tag = "4")]
747    pub if_not_exists: bool,
748    #[prost(message, optional, tag = "5")]
749    pub resource_type: ::core::option::Option<StreamingJobResourceType>,
750}
751#[derive(prost_helpers::AnyPB)]
752#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
753pub struct CreateIndexResponse {
754    #[prost(message, optional, tag = "1")]
755    pub status: ::core::option::Option<super::common::Status>,
756    #[prost(message, optional, tag = "2")]
757    pub version: ::core::option::Option<WaitVersion>,
758}
759#[derive(prost_helpers::AnyPB)]
760#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
761pub struct DropIndexRequest {
762    #[prost(uint32, tag = "1", wrapper = "crate::id::IndexId")]
763    pub index_id: crate::id::IndexId,
764    #[prost(bool, tag = "2")]
765    pub cascade: bool,
766}
767#[derive(prost_helpers::AnyPB)]
768#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
769pub struct DropIndexResponse {
770    #[prost(message, optional, tag = "1")]
771    pub status: ::core::option::Option<super::common::Status>,
772    #[prost(message, optional, tag = "2")]
773    pub version: ::core::option::Option<WaitVersion>,
774}
775#[derive(prost_helpers::AnyPB)]
776#[derive(Clone, PartialEq, ::prost::Message)]
777pub struct ReplaceJobPlan {
778    /// The new materialization plan, where all schema are updated.
779    #[prost(message, optional, tag = "1")]
780    pub fragment_graph: ::core::option::Option<super::stream_plan::StreamFragmentGraph>,
781    #[prost(oneof = "replace_job_plan::ReplaceJob", tags = "3, 4, 5, 6")]
782    pub replace_job: ::core::option::Option<replace_job_plan::ReplaceJob>,
783}
784/// Nested message and enum types in `ReplaceJobPlan`.
785pub mod replace_job_plan {
786    #[derive(prost_helpers::AnyPB)]
787    #[derive(Clone, PartialEq, ::prost::Message)]
788    pub struct ReplaceTable {
789        /// The new table catalog, with the correct (old) table ID and a new version.
790        /// If the new version does not match the subsequent version in the meta service's
791        /// catalog, this request will be rejected.
792        #[prost(message, optional, tag = "1")]
793        pub table: ::core::option::Option<super::super::catalog::Table>,
794        /// Source catalog of table's associated source
795        #[prost(message, optional, tag = "2")]
796        pub source: ::core::option::Option<super::super::catalog::Source>,
797        #[prost(enumeration = "super::TableJobType", tag = "3")]
798        pub job_type: i32,
799    }
800    #[derive(prost_helpers::AnyPB)]
801    #[derive(Clone, PartialEq, ::prost::Message)]
802    pub struct ReplaceSource {
803        #[prost(message, optional, tag = "1")]
804        pub source: ::core::option::Option<super::super::catalog::Source>,
805    }
806    #[derive(prost_helpers::AnyPB)]
807    #[derive(Clone, PartialEq, ::prost::Message)]
808    pub struct ReplaceMaterializedView {
809        #[prost(message, optional, tag = "1")]
810        pub table: ::core::option::Option<super::super::catalog::Table>,
811    }
812    #[derive(prost_helpers::AnyPB)]
813    #[derive(Clone, PartialEq, ::prost::Message)]
814    pub struct ReplaceSink {
815        #[prost(message, optional, tag = "1")]
816        pub sink: ::core::option::Option<super::super::catalog::Sink>,
817        #[prost(uint32, tag = "2", wrapper = "crate::id::SinkId")]
818        pub old_sink_id: crate::id::SinkId,
819        /// The list of object IDs that the new sink depends on.
820        #[prost(uint32, repeated, tag = "3", wrapper = "crate::id::ObjectId")]
821        pub dependencies: ::prost::alloc::vec::Vec<crate::id::ObjectId>,
822        #[prost(message, optional, tag = "4")]
823        pub resource_type: ::core::option::Option<super::StreamingJobResourceType>,
824    }
825    #[derive(prost_helpers::AnyPB)]
826    #[derive(Clone, PartialEq, ::prost::Oneof)]
827    pub enum ReplaceJob {
828        #[prost(message, tag = "3")]
829        ReplaceTable(ReplaceTable),
830        #[prost(message, tag = "4")]
831        ReplaceSource(ReplaceSource),
832        #[prost(message, tag = "5")]
833        ReplaceMaterializedView(ReplaceMaterializedView),
834        #[prost(message, tag = "6")]
835        ReplaceSink(ReplaceSink),
836    }
837}
838#[derive(prost_helpers::AnyPB)]
839#[derive(Clone, PartialEq, ::prost::Message)]
840pub struct ReplaceJobPlanRequest {
841    #[prost(message, optional, tag = "1")]
842    pub plan: ::core::option::Option<ReplaceJobPlan>,
843}
844#[derive(prost_helpers::AnyPB)]
845#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
846pub struct ReplaceJobPlanResponse {
847    #[prost(message, optional, tag = "1")]
848    pub status: ::core::option::Option<super::common::Status>,
849    /// The new global catalog version.
850    #[prost(message, optional, tag = "2")]
851    pub version: ::core::option::Option<WaitVersion>,
852}
853#[derive(prost_helpers::AnyPB)]
854#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
855pub struct GetTableRequest {
856    #[prost(string, tag = "1")]
857    pub database_name: ::prost::alloc::string::String,
858    #[prost(string, tag = "2")]
859    pub table_name: ::prost::alloc::string::String,
860}
861#[derive(prost_helpers::AnyPB)]
862#[derive(Clone, PartialEq, ::prost::Message)]
863pub struct GetTableResponse {
864    #[prost(message, optional, tag = "1")]
865    pub table: ::core::option::Option<super::catalog::Table>,
866}
867#[derive(prost_helpers::AnyPB)]
868#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
869pub struct GetDdlProgressRequest {}
870#[derive(prost_helpers::AnyPB)]
871#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
872pub struct DdlProgress {
873    #[prost(uint64, tag = "1")]
874    pub id: u64,
875    #[prost(string, tag = "2")]
876    pub statement: ::prost::alloc::string::String,
877    #[prost(string, tag = "3")]
878    pub progress: ::prost::alloc::string::String,
879    #[prost(string, tag = "4")]
880    pub create_type: ::prost::alloc::string::String,
881    #[prost(int64, tag = "5")]
882    pub initialized_at_time_millis: i64,
883    #[prost(bool, tag = "6")]
884    pub is_serverless_backfill: bool,
885    #[prost(enumeration = "BackfillType", tag = "7")]
886    pub backfill_type: i32,
887}
888#[derive(prost_helpers::AnyPB)]
889#[derive(Clone, PartialEq, ::prost::Message)]
890pub struct GetDdlProgressResponse {
891    #[prost(message, repeated, tag = "1")]
892    pub ddl_progress: ::prost::alloc::vec::Vec<DdlProgress>,
893}
894#[derive(prost_helpers::AnyPB)]
895#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
896pub struct CreateSecretRequest {
897    #[prost(string, tag = "1")]
898    pub name: ::prost::alloc::string::String,
899    #[prost(bytes = "vec", tag = "2")]
900    pub value: ::prost::alloc::vec::Vec<u8>,
901    #[prost(uint32, tag = "3", wrapper = "crate::id::DatabaseId")]
902    pub database_id: crate::id::DatabaseId,
903    #[prost(uint32, tag = "4", wrapper = "crate::id::SchemaId")]
904    pub schema_id: crate::id::SchemaId,
905    #[prost(uint32, tag = "5", wrapper = "crate::id::UserId")]
906    pub owner_id: crate::id::UserId,
907}
908#[derive(prost_helpers::AnyPB)]
909#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
910pub struct CreateSecretResponse {
911    #[prost(message, optional, tag = "1")]
912    pub version: ::core::option::Option<WaitVersion>,
913}
914#[derive(prost_helpers::AnyPB)]
915#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
916pub struct DropSecretRequest {
917    #[prost(uint32, tag = "1", wrapper = "crate::id::SecretId")]
918    pub secret_id: crate::id::SecretId,
919    #[prost(bool, tag = "2")]
920    pub cascade: bool,
921}
922#[derive(prost_helpers::AnyPB)]
923#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
924pub struct DropSecretResponse {
925    #[prost(message, optional, tag = "1")]
926    pub version: ::core::option::Option<WaitVersion>,
927    #[prost(message, optional, tag = "2")]
928    pub status: ::core::option::Option<super::common::Status>,
929}
930#[derive(prost_helpers::AnyPB)]
931#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
932pub struct AlterSecretRequest {
933    #[prost(uint32, tag = "1", wrapper = "crate::id::SecretId")]
934    pub secret_id: crate::id::SecretId,
935    #[prost(string, tag = "2")]
936    pub name: ::prost::alloc::string::String,
937    #[prost(bytes = "vec", tag = "3")]
938    pub value: ::prost::alloc::vec::Vec<u8>,
939    #[prost(uint32, tag = "4", wrapper = "crate::id::DatabaseId")]
940    pub database_id: crate::id::DatabaseId,
941    #[prost(uint32, tag = "5", wrapper = "crate::id::SchemaId")]
942    pub schema_id: crate::id::SchemaId,
943    #[prost(uint32, tag = "6", wrapper = "crate::id::UserId")]
944    pub owner_id: crate::id::UserId,
945}
946#[derive(prost_helpers::AnyPB)]
947#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
948pub struct AlterSecretResponse {
949    #[prost(message, optional, tag = "1")]
950    pub version: ::core::option::Option<WaitVersion>,
951}
952#[derive(prost_helpers::AnyPB)]
953#[derive(Clone, PartialEq, ::prost::Message)]
954pub struct CreateConnectionRequest {
955    #[prost(string, tag = "1")]
956    pub name: ::prost::alloc::string::String,
957    #[prost(uint32, tag = "2", wrapper = "crate::id::DatabaseId")]
958    pub database_id: crate::id::DatabaseId,
959    #[prost(uint32, tag = "3", wrapper = "crate::id::SchemaId")]
960    pub schema_id: crate::id::SchemaId,
961    #[prost(uint32, tag = "5", wrapper = "crate::id::UserId")]
962    pub owner_id: crate::id::UserId,
963    #[prost(oneof = "create_connection_request::Payload", tags = "4, 6")]
964    pub payload: ::core::option::Option<create_connection_request::Payload>,
965}
966/// Nested message and enum types in `CreateConnectionRequest`.
967pub mod create_connection_request {
968    #[derive(prost_helpers::AnyPB)]
969    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
970    pub struct PrivateLink {
971        #[prost(
972            enumeration = "super::super::catalog::connection::private_link_service::PrivateLinkProvider",
973            tag = "1"
974        )]
975        pub provider: i32,
976        #[prost(string, tag = "2")]
977        pub service_name: ::prost::alloc::string::String,
978        #[prost(string, optional, tag = "3")]
979        pub tags: ::core::option::Option<::prost::alloc::string::String>,
980    }
981    #[derive(prost_helpers::AnyPB)]
982    #[derive(Clone, PartialEq, ::prost::Oneof)]
983    pub enum Payload {
984        #[deprecated]
985        #[prost(message, tag = "4")]
986        PrivateLink(PrivateLink),
987        #[prost(message, tag = "6")]
988        ConnectionParams(super::super::catalog::ConnectionParams),
989    }
990}
991#[derive(prost_helpers::AnyPB)]
992#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
993pub struct CreateConnectionResponse {
994    /// global catalog version
995    #[prost(message, optional, tag = "1")]
996    pub version: ::core::option::Option<WaitVersion>,
997}
998#[derive(prost_helpers::AnyPB)]
999#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1000pub struct ListConnectionsRequest {}
1001#[derive(prost_helpers::AnyPB)]
1002#[derive(Clone, PartialEq, ::prost::Message)]
1003pub struct ListConnectionsResponse {
1004    #[prost(message, repeated, tag = "1")]
1005    pub connections: ::prost::alloc::vec::Vec<super::catalog::Connection>,
1006}
1007#[derive(prost_helpers::AnyPB)]
1008#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1009pub struct DropConnectionRequest {
1010    #[prost(uint32, tag = "1", wrapper = "crate::id::ConnectionId")]
1011    pub connection_id: crate::id::ConnectionId,
1012    #[prost(bool, tag = "2")]
1013    pub cascade: bool,
1014}
1015#[derive(prost_helpers::AnyPB)]
1016#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1017pub struct DropConnectionResponse {
1018    #[prost(message, optional, tag = "1")]
1019    pub status: ::core::option::Option<super::common::Status>,
1020    #[prost(message, optional, tag = "2")]
1021    pub version: ::core::option::Option<WaitVersion>,
1022}
1023#[derive(prost_helpers::AnyPB)]
1024#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1025pub struct GetTablesRequest {
1026    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::TableId")]
1027    pub table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
1028    #[prost(bool, tag = "2")]
1029    pub include_dropped_tables: bool,
1030}
1031#[derive(prost_helpers::AnyPB)]
1032#[derive(Clone, PartialEq, ::prost::Message)]
1033pub struct GetTablesResponse {
1034    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::TableId")]
1035    pub tables: ::std::collections::HashMap<crate::id::TableId, super::catalog::Table>,
1036}
1037#[derive(prost_helpers::AnyPB)]
1038#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1039pub struct WaitRequest {
1040    #[prost(uint32, optional, tag = "1", wrapper = "crate::id::JobId")]
1041    pub job_id: ::core::option::Option<crate::id::JobId>,
1042}
1043#[derive(prost_helpers::AnyPB)]
1044#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1045pub struct WaitResponse {
1046    #[prost(message, optional, tag = "1")]
1047    pub version: ::core::option::Option<WaitVersion>,
1048}
1049#[derive(prost_helpers::AnyPB)]
1050#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1051pub struct CommentOnRequest {
1052    #[prost(message, optional, tag = "1")]
1053    pub comment: ::core::option::Option<super::catalog::Comment>,
1054}
1055#[derive(prost_helpers::AnyPB)]
1056#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1057pub struct CommentOnResponse {
1058    #[prost(message, optional, tag = "1")]
1059    pub status: ::core::option::Option<super::common::Status>,
1060    #[prost(message, optional, tag = "2")]
1061    pub version: ::core::option::Option<WaitVersion>,
1062}
1063#[derive(prost_helpers::AnyPB)]
1064#[derive(Clone, PartialEq, ::prost::Message)]
1065pub struct TableSchemaChange {
1066    #[prost(enumeration = "table_schema_change::TableChangeType", tag = "1")]
1067    pub change_type: i32,
1068    #[prost(string, tag = "2")]
1069    pub cdc_table_id: ::prost::alloc::string::String,
1070    #[prost(message, repeated, tag = "3")]
1071    pub columns: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
1072    #[prost(string, tag = "4")]
1073    pub upstream_ddl: ::prost::alloc::string::String,
1074}
1075/// Nested message and enum types in `TableSchemaChange`.
1076pub mod table_schema_change {
1077    #[derive(prost_helpers::AnyPB)]
1078    #[derive(
1079        Clone,
1080        Copy,
1081        Debug,
1082        PartialEq,
1083        Eq,
1084        Hash,
1085        PartialOrd,
1086        Ord,
1087        ::prost::Enumeration
1088    )]
1089    #[repr(i32)]
1090    pub enum TableChangeType {
1091        Unspecified = 0,
1092        Alter = 1,
1093        Create = 2,
1094        Drop = 3,
1095    }
1096    impl TableChangeType {
1097        /// String value of the enum field names used in the ProtoBuf definition.
1098        ///
1099        /// The values are not transformed in any way and thus are considered stable
1100        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1101        pub fn as_str_name(&self) -> &'static str {
1102            match self {
1103                Self::Unspecified => "UNSPECIFIED",
1104                Self::Alter => "ALTER",
1105                Self::Create => "CREATE",
1106                Self::Drop => "DROP",
1107            }
1108        }
1109        /// Creates an enum from field names used in the ProtoBuf definition.
1110        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1111            match value {
1112                "UNSPECIFIED" => Some(Self::Unspecified),
1113                "ALTER" => Some(Self::Alter),
1114                "CREATE" => Some(Self::Create),
1115                "DROP" => Some(Self::Drop),
1116                _ => None,
1117            }
1118        }
1119    }
1120}
1121#[derive(prost_helpers::AnyPB)]
1122#[derive(Clone, PartialEq, ::prost::Message)]
1123pub struct SchemaChangeEnvelope {
1124    #[prost(message, repeated, tag = "1")]
1125    pub table_changes: ::prost::alloc::vec::Vec<TableSchemaChange>,
1126}
1127#[derive(prost_helpers::AnyPB)]
1128#[derive(Clone, PartialEq, ::prost::Message)]
1129pub struct AutoSchemaChangeRequest {
1130    #[prost(message, optional, tag = "1")]
1131    pub schema_change: ::core::option::Option<SchemaChangeEnvelope>,
1132}
1133#[derive(prost_helpers::AnyPB)]
1134#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1135pub struct AutoSchemaChangeResponse {}
1136#[derive(prost_helpers::AnyPB)]
1137#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1138pub struct AlterDatabaseParamRequest {
1139    #[prost(uint32, tag = "1", wrapper = "crate::id::DatabaseId")]
1140    pub database_id: crate::id::DatabaseId,
1141    #[prost(oneof = "alter_database_param_request::Param", tags = "2, 3")]
1142    pub param: ::core::option::Option<alter_database_param_request::Param>,
1143}
1144/// Nested message and enum types in `AlterDatabaseParamRequest`.
1145pub mod alter_database_param_request {
1146    #[derive(prost_helpers::AnyPB)]
1147    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
1148    pub enum Param {
1149        #[prost(message, tag = "2")]
1150        BarrierIntervalMs(super::super::common::OptionalUint32),
1151        #[prost(message, tag = "3")]
1152        CheckpointFrequency(super::super::common::OptionalUint64),
1153    }
1154}
1155#[derive(prost_helpers::AnyPB)]
1156#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1157pub struct AlterDatabaseParamResponse {
1158    #[prost(message, optional, tag = "1")]
1159    pub status: ::core::option::Option<super::common::Status>,
1160    #[prost(message, optional, tag = "2")]
1161    pub version: ::core::option::Option<WaitVersion>,
1162}
1163#[derive(prost_helpers::AnyPB)]
1164#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1165pub struct CompactIcebergTableRequest {
1166    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
1167    pub sink_id: crate::id::SinkId,
1168}
1169#[derive(prost_helpers::AnyPB)]
1170#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1171pub struct CompactIcebergTableResponse {
1172    #[prost(message, optional, tag = "1")]
1173    pub status: ::core::option::Option<super::common::Status>,
1174    /// The compaction task ID that was triggered
1175    #[prost(uint64, tag = "2", wrapper = "crate::id::IcebergCompactionTaskId")]
1176    pub task_id: crate::id::IcebergCompactionTaskId,
1177}
1178#[derive(prost_helpers::AnyPB)]
1179#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1180pub struct RewriteIcebergTableManifestsRequest {
1181    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
1182    pub sink_id: crate::id::SinkId,
1183}
1184#[derive(prost_helpers::AnyPB)]
1185#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1186pub struct RewriteIcebergTableManifestsResponse {
1187    #[prost(message, optional, tag = "1")]
1188    pub status: ::core::option::Option<super::common::Status>,
1189}
1190#[derive(prost_helpers::AnyPB)]
1191#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1192pub struct ExpireIcebergTableSnapshotsRequest {
1193    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
1194    pub sink_id: crate::id::SinkId,
1195}
1196#[derive(prost_helpers::AnyPB)]
1197#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1198pub struct ExpireIcebergTableSnapshotsResponse {
1199    #[prost(message, optional, tag = "1")]
1200    pub status: ::core::option::Option<super::common::Status>,
1201}
1202#[derive(prost_helpers::AnyPB)]
1203#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1204pub struct RemoveIcebergTableOrphanFilesRequest {
1205    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
1206    pub sink_id: crate::id::SinkId,
1207}
1208#[derive(prost_helpers::AnyPB)]
1209#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1210pub struct RemoveIcebergTableOrphanFilesResponse {
1211    #[prost(message, optional, tag = "1")]
1212    pub status: ::core::option::Option<super::common::Status>,
1213    #[prost(uint64, tag = "2")]
1214    pub orphan_file_count: u64,
1215}
1216#[derive(prost_helpers::AnyPB)]
1217#[derive(Clone, PartialEq, ::prost::Message)]
1218pub struct AlterStreamingJobConfigRequest {
1219    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
1220    pub job_id: crate::id::JobId,
1221    #[prost(map = "string, string", tag = "2")]
1222    pub entries_to_add: ::std::collections::HashMap<
1223        ::prost::alloc::string::String,
1224        ::prost::alloc::string::String,
1225    >,
1226    #[prost(string, repeated, tag = "3")]
1227    pub keys_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1228}
1229#[derive(prost_helpers::AnyPB)]
1230#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1231pub struct AlterStreamingJobConfigResponse {}
1232#[derive(prost_helpers::AnyPB)]
1233#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1234pub struct WaitIcebergPkIndexSinkEpochRequest {
1235    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
1236    pub sink_id: crate::id::SinkId,
1237    #[prost(uint64, tag = "2")]
1238    pub epoch: u64,
1239}
1240#[derive(prost_helpers::AnyPB)]
1241#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1242pub struct WaitIcebergPkIndexSinkEpochResponse {
1243    /// The coordinator's committed iceberg snapshot id at/after `epoch`.
1244    /// Absent when the table has no committed snapshot yet.
1245    #[prost(int64, optional, tag = "1")]
1246    pub snapshot_id: ::core::option::Option<i64>,
1247}
1248/// An enum to distinguish different types of the `Table` streaming job.
1249///
1250/// * GENERAL: Table streaming jobs w/ or w/o a connector
1251/// * SHARED_CDC_SOURCE: The table streaming job is created based on a shared CDC source job (risingwavelabs/rfcs#73).
1252///
1253/// And one may add other types to support Table jobs that based on other shared sources (risingwavelabs/rfcs#72).
1254///
1255/// Currently, it's usages include:
1256///
1257/// * When creating the streaming actor graph, different table jobs may need different treatment.
1258/// * Some adhoc validation when creating the streaming job. e.g., `validate_cdc_table`.
1259///
1260/// It's not included in `catalog.Table`, and thus not persisted. It's only used in the `CreateTableRequest`.
1261#[derive(prost_helpers::AnyPB)]
1262#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1263#[repr(i32)]
1264pub enum TableJobType {
1265    Unspecified = 0,
1266    /// table streaming jobs excepts the `SHARED_CDC_SOURCE` type
1267    General = 1,
1268    /// table streaming job sharing a CDC source job
1269    SharedCdcSource = 2,
1270}
1271impl TableJobType {
1272    /// String value of the enum field names used in the ProtoBuf definition.
1273    ///
1274    /// The values are not transformed in any way and thus are considered stable
1275    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1276    pub fn as_str_name(&self) -> &'static str {
1277        match self {
1278            Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
1279            Self::General => "TABLE_JOB_TYPE_GENERAL",
1280            Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
1281        }
1282    }
1283    /// Creates an enum from field names used in the ProtoBuf definition.
1284    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1285        match value {
1286            "TABLE_JOB_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
1287            "TABLE_JOB_TYPE_GENERAL" => Some(Self::General),
1288            "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Some(Self::SharedCdcSource),
1289            _ => None,
1290        }
1291    }
1292}
1293#[derive(prost_helpers::AnyPB)]
1294#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1295#[repr(i32)]
1296pub enum BackfillType {
1297    Unspecified = 0,
1298    NormalBackfill = 1,
1299    SnapshotBackfill = 2,
1300}
1301impl BackfillType {
1302    /// String value of the enum field names used in the ProtoBuf definition.
1303    ///
1304    /// The values are not transformed in any way and thus are considered stable
1305    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1306    pub fn as_str_name(&self) -> &'static str {
1307        match self {
1308            Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
1309            Self::NormalBackfill => "NORMAL_BACKFILL",
1310            Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
1311        }
1312    }
1313    /// Creates an enum from field names used in the ProtoBuf definition.
1314    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1315        match value {
1316            "BACKFILL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
1317            "NORMAL_BACKFILL" => Some(Self::NormalBackfill),
1318            "SNAPSHOT_BACKFILL" => Some(Self::SnapshotBackfill),
1319            _ => None,
1320        }
1321    }
1322}
1323/// Generated client implementations.
1324pub mod ddl_service_client {
1325    #![allow(
1326        unused_variables,
1327        dead_code,
1328        missing_docs,
1329        clippy::wildcard_imports,
1330        clippy::let_unit_value,
1331    )]
1332    use tonic::codegen::*;
1333    use tonic::codegen::http::Uri;
1334    #[derive(Debug, Clone)]
1335    pub struct DdlServiceClient<T> {
1336        inner: tonic::client::Grpc<T>,
1337    }
1338    impl DdlServiceClient<tonic::transport::Channel> {
1339        /// Attempt to create a new client by connecting to a given endpoint.
1340        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1341        where
1342            D: TryInto<tonic::transport::Endpoint>,
1343            D::Error: Into<StdError>,
1344        {
1345            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1346            Ok(Self::new(conn))
1347        }
1348    }
1349    impl<T> DdlServiceClient<T>
1350    where
1351        T: tonic::client::GrpcService<tonic::body::Body>,
1352        T::Error: Into<StdError>,
1353        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
1354        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
1355    {
1356        pub fn new(inner: T) -> Self {
1357            let inner = tonic::client::Grpc::new(inner);
1358            Self { inner }
1359        }
1360        pub fn with_origin(inner: T, origin: Uri) -> Self {
1361            let inner = tonic::client::Grpc::with_origin(inner, origin);
1362            Self { inner }
1363        }
1364        pub fn with_interceptor<F>(
1365            inner: T,
1366            interceptor: F,
1367        ) -> DdlServiceClient<InterceptedService<T, F>>
1368        where
1369            F: tonic::service::Interceptor,
1370            T::ResponseBody: Default,
1371            T: tonic::codegen::Service<
1372                http::Request<tonic::body::Body>,
1373                Response = http::Response<
1374                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
1375                >,
1376            >,
1377            <T as tonic::codegen::Service<
1378                http::Request<tonic::body::Body>,
1379            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1380        {
1381            DdlServiceClient::new(InterceptedService::new(inner, interceptor))
1382        }
1383        /// Compress requests with the given encoding.
1384        ///
1385        /// This requires the server to support it otherwise it might respond with an
1386        /// error.
1387        #[must_use]
1388        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1389            self.inner = self.inner.send_compressed(encoding);
1390            self
1391        }
1392        /// Enable decompressing responses.
1393        #[must_use]
1394        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1395            self.inner = self.inner.accept_compressed(encoding);
1396            self
1397        }
1398        /// Limits the maximum size of a decoded message.
1399        ///
1400        /// Default: `4MB`
1401        #[must_use]
1402        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1403            self.inner = self.inner.max_decoding_message_size(limit);
1404            self
1405        }
1406        /// Limits the maximum size of an encoded message.
1407        ///
1408        /// Default: `usize::MAX`
1409        #[must_use]
1410        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1411            self.inner = self.inner.max_encoding_message_size(limit);
1412            self
1413        }
1414        pub async fn create_database(
1415            &mut self,
1416            request: impl tonic::IntoRequest<super::CreateDatabaseRequest>,
1417        ) -> std::result::Result<
1418            tonic::Response<super::CreateDatabaseResponse>,
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_prost::ProstCodec::default();
1430            let path = http::uri::PathAndQuery::from_static(
1431                "/ddl_service.DdlService/CreateDatabase",
1432            );
1433            let mut req = request.into_request();
1434            req.extensions_mut()
1435                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateDatabase"));
1436            self.inner.unary(req, path, codec).await
1437        }
1438        pub async fn drop_database(
1439            &mut self,
1440            request: impl tonic::IntoRequest<super::DropDatabaseRequest>,
1441        ) -> std::result::Result<
1442            tonic::Response<super::DropDatabaseResponse>,
1443            tonic::Status,
1444        > {
1445            self.inner
1446                .ready()
1447                .await
1448                .map_err(|e| {
1449                    tonic::Status::unknown(
1450                        format!("Service was not ready: {}", e.into()),
1451                    )
1452                })?;
1453            let codec = tonic_prost::ProstCodec::default();
1454            let path = http::uri::PathAndQuery::from_static(
1455                "/ddl_service.DdlService/DropDatabase",
1456            );
1457            let mut req = request.into_request();
1458            req.extensions_mut()
1459                .insert(GrpcMethod::new("ddl_service.DdlService", "DropDatabase"));
1460            self.inner.unary(req, path, codec).await
1461        }
1462        pub async fn create_schema(
1463            &mut self,
1464            request: impl tonic::IntoRequest<super::CreateSchemaRequest>,
1465        ) -> std::result::Result<
1466            tonic::Response<super::CreateSchemaResponse>,
1467            tonic::Status,
1468        > {
1469            self.inner
1470                .ready()
1471                .await
1472                .map_err(|e| {
1473                    tonic::Status::unknown(
1474                        format!("Service was not ready: {}", e.into()),
1475                    )
1476                })?;
1477            let codec = tonic_prost::ProstCodec::default();
1478            let path = http::uri::PathAndQuery::from_static(
1479                "/ddl_service.DdlService/CreateSchema",
1480            );
1481            let mut req = request.into_request();
1482            req.extensions_mut()
1483                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSchema"));
1484            self.inner.unary(req, path, codec).await
1485        }
1486        pub async fn drop_schema(
1487            &mut self,
1488            request: impl tonic::IntoRequest<super::DropSchemaRequest>,
1489        ) -> std::result::Result<
1490            tonic::Response<super::DropSchemaResponse>,
1491            tonic::Status,
1492        > {
1493            self.inner
1494                .ready()
1495                .await
1496                .map_err(|e| {
1497                    tonic::Status::unknown(
1498                        format!("Service was not ready: {}", e.into()),
1499                    )
1500                })?;
1501            let codec = tonic_prost::ProstCodec::default();
1502            let path = http::uri::PathAndQuery::from_static(
1503                "/ddl_service.DdlService/DropSchema",
1504            );
1505            let mut req = request.into_request();
1506            req.extensions_mut()
1507                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSchema"));
1508            self.inner.unary(req, path, codec).await
1509        }
1510        pub async fn create_source(
1511            &mut self,
1512            request: impl tonic::IntoRequest<super::CreateSourceRequest>,
1513        ) -> std::result::Result<
1514            tonic::Response<super::CreateSourceResponse>,
1515            tonic::Status,
1516        > {
1517            self.inner
1518                .ready()
1519                .await
1520                .map_err(|e| {
1521                    tonic::Status::unknown(
1522                        format!("Service was not ready: {}", e.into()),
1523                    )
1524                })?;
1525            let codec = tonic_prost::ProstCodec::default();
1526            let path = http::uri::PathAndQuery::from_static(
1527                "/ddl_service.DdlService/CreateSource",
1528            );
1529            let mut req = request.into_request();
1530            req.extensions_mut()
1531                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSource"));
1532            self.inner.unary(req, path, codec).await
1533        }
1534        pub async fn drop_source(
1535            &mut self,
1536            request: impl tonic::IntoRequest<super::DropSourceRequest>,
1537        ) -> std::result::Result<
1538            tonic::Response<super::DropSourceResponse>,
1539            tonic::Status,
1540        > {
1541            self.inner
1542                .ready()
1543                .await
1544                .map_err(|e| {
1545                    tonic::Status::unknown(
1546                        format!("Service was not ready: {}", e.into()),
1547                    )
1548                })?;
1549            let codec = tonic_prost::ProstCodec::default();
1550            let path = http::uri::PathAndQuery::from_static(
1551                "/ddl_service.DdlService/DropSource",
1552            );
1553            let mut req = request.into_request();
1554            req.extensions_mut()
1555                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSource"));
1556            self.inner.unary(req, path, codec).await
1557        }
1558        pub async fn create_sink(
1559            &mut self,
1560            request: impl tonic::IntoRequest<super::CreateSinkRequest>,
1561        ) -> std::result::Result<
1562            tonic::Response<super::CreateSinkResponse>,
1563            tonic::Status,
1564        > {
1565            self.inner
1566                .ready()
1567                .await
1568                .map_err(|e| {
1569                    tonic::Status::unknown(
1570                        format!("Service was not ready: {}", e.into()),
1571                    )
1572                })?;
1573            let codec = tonic_prost::ProstCodec::default();
1574            let path = http::uri::PathAndQuery::from_static(
1575                "/ddl_service.DdlService/CreateSink",
1576            );
1577            let mut req = request.into_request();
1578            req.extensions_mut()
1579                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSink"));
1580            self.inner.unary(req, path, codec).await
1581        }
1582        pub async fn create_subscription(
1583            &mut self,
1584            request: impl tonic::IntoRequest<super::CreateSubscriptionRequest>,
1585        ) -> std::result::Result<
1586            tonic::Response<super::CreateSubscriptionResponse>,
1587            tonic::Status,
1588        > {
1589            self.inner
1590                .ready()
1591                .await
1592                .map_err(|e| {
1593                    tonic::Status::unknown(
1594                        format!("Service was not ready: {}", e.into()),
1595                    )
1596                })?;
1597            let codec = tonic_prost::ProstCodec::default();
1598            let path = http::uri::PathAndQuery::from_static(
1599                "/ddl_service.DdlService/CreateSubscription",
1600            );
1601            let mut req = request.into_request();
1602            req.extensions_mut()
1603                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSubscription"));
1604            self.inner.unary(req, path, codec).await
1605        }
1606        pub async fn drop_sink(
1607            &mut self,
1608            request: impl tonic::IntoRequest<super::DropSinkRequest>,
1609        ) -> std::result::Result<
1610            tonic::Response<super::DropSinkResponse>,
1611            tonic::Status,
1612        > {
1613            self.inner
1614                .ready()
1615                .await
1616                .map_err(|e| {
1617                    tonic::Status::unknown(
1618                        format!("Service was not ready: {}", e.into()),
1619                    )
1620                })?;
1621            let codec = tonic_prost::ProstCodec::default();
1622            let path = http::uri::PathAndQuery::from_static(
1623                "/ddl_service.DdlService/DropSink",
1624            );
1625            let mut req = request.into_request();
1626            req.extensions_mut()
1627                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSink"));
1628            self.inner.unary(req, path, codec).await
1629        }
1630        pub async fn drop_subscription(
1631            &mut self,
1632            request: impl tonic::IntoRequest<super::DropSubscriptionRequest>,
1633        ) -> std::result::Result<
1634            tonic::Response<super::DropSubscriptionResponse>,
1635            tonic::Status,
1636        > {
1637            self.inner
1638                .ready()
1639                .await
1640                .map_err(|e| {
1641                    tonic::Status::unknown(
1642                        format!("Service was not ready: {}", e.into()),
1643                    )
1644                })?;
1645            let codec = tonic_prost::ProstCodec::default();
1646            let path = http::uri::PathAndQuery::from_static(
1647                "/ddl_service.DdlService/DropSubscription",
1648            );
1649            let mut req = request.into_request();
1650            req.extensions_mut()
1651                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSubscription"));
1652            self.inner.unary(req, path, codec).await
1653        }
1654        pub async fn create_materialized_view(
1655            &mut self,
1656            request: impl tonic::IntoRequest<super::CreateMaterializedViewRequest>,
1657        ) -> std::result::Result<
1658            tonic::Response<super::CreateMaterializedViewResponse>,
1659            tonic::Status,
1660        > {
1661            self.inner
1662                .ready()
1663                .await
1664                .map_err(|e| {
1665                    tonic::Status::unknown(
1666                        format!("Service was not ready: {}", e.into()),
1667                    )
1668                })?;
1669            let codec = tonic_prost::ProstCodec::default();
1670            let path = http::uri::PathAndQuery::from_static(
1671                "/ddl_service.DdlService/CreateMaterializedView",
1672            );
1673            let mut req = request.into_request();
1674            req.extensions_mut()
1675                .insert(
1676                    GrpcMethod::new("ddl_service.DdlService", "CreateMaterializedView"),
1677                );
1678            self.inner.unary(req, path, codec).await
1679        }
1680        pub async fn drop_materialized_view(
1681            &mut self,
1682            request: impl tonic::IntoRequest<super::DropMaterializedViewRequest>,
1683        ) -> std::result::Result<
1684            tonic::Response<super::DropMaterializedViewResponse>,
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_prost::ProstCodec::default();
1696            let path = http::uri::PathAndQuery::from_static(
1697                "/ddl_service.DdlService/DropMaterializedView",
1698            );
1699            let mut req = request.into_request();
1700            req.extensions_mut()
1701                .insert(
1702                    GrpcMethod::new("ddl_service.DdlService", "DropMaterializedView"),
1703                );
1704            self.inner.unary(req, path, codec).await
1705        }
1706        pub async fn create_table(
1707            &mut self,
1708            request: impl tonic::IntoRequest<super::CreateTableRequest>,
1709        ) -> std::result::Result<
1710            tonic::Response<super::CreateTableResponse>,
1711            tonic::Status,
1712        > {
1713            self.inner
1714                .ready()
1715                .await
1716                .map_err(|e| {
1717                    tonic::Status::unknown(
1718                        format!("Service was not ready: {}", e.into()),
1719                    )
1720                })?;
1721            let codec = tonic_prost::ProstCodec::default();
1722            let path = http::uri::PathAndQuery::from_static(
1723                "/ddl_service.DdlService/CreateTable",
1724            );
1725            let mut req = request.into_request();
1726            req.extensions_mut()
1727                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateTable"));
1728            self.inner.unary(req, path, codec).await
1729        }
1730        pub async fn create_iceberg_table(
1731            &mut self,
1732            request: impl tonic::IntoRequest<super::CreateIcebergTableRequest>,
1733        ) -> std::result::Result<
1734            tonic::Response<super::CreateIcebergTableResponse>,
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_prost::ProstCodec::default();
1746            let path = http::uri::PathAndQuery::from_static(
1747                "/ddl_service.DdlService/CreateIcebergTable",
1748            );
1749            let mut req = request.into_request();
1750            req.extensions_mut()
1751                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateIcebergTable"));
1752            self.inner.unary(req, path, codec).await
1753        }
1754        pub async fn create_secret(
1755            &mut self,
1756            request: impl tonic::IntoRequest<super::CreateSecretRequest>,
1757        ) -> std::result::Result<
1758            tonic::Response<super::CreateSecretResponse>,
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_prost::ProstCodec::default();
1770            let path = http::uri::PathAndQuery::from_static(
1771                "/ddl_service.DdlService/CreateSecret",
1772            );
1773            let mut req = request.into_request();
1774            req.extensions_mut()
1775                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSecret"));
1776            self.inner.unary(req, path, codec).await
1777        }
1778        pub async fn drop_secret(
1779            &mut self,
1780            request: impl tonic::IntoRequest<super::DropSecretRequest>,
1781        ) -> std::result::Result<
1782            tonic::Response<super::DropSecretResponse>,
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_prost::ProstCodec::default();
1794            let path = http::uri::PathAndQuery::from_static(
1795                "/ddl_service.DdlService/DropSecret",
1796            );
1797            let mut req = request.into_request();
1798            req.extensions_mut()
1799                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSecret"));
1800            self.inner.unary(req, path, codec).await
1801        }
1802        pub async fn alter_secret(
1803            &mut self,
1804            request: impl tonic::IntoRequest<super::AlterSecretRequest>,
1805        ) -> std::result::Result<
1806            tonic::Response<super::AlterSecretResponse>,
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_prost::ProstCodec::default();
1818            let path = http::uri::PathAndQuery::from_static(
1819                "/ddl_service.DdlService/AlterSecret",
1820            );
1821            let mut req = request.into_request();
1822            req.extensions_mut()
1823                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSecret"));
1824            self.inner.unary(req, path, codec).await
1825        }
1826        pub async fn alter_name(
1827            &mut self,
1828            request: impl tonic::IntoRequest<super::AlterNameRequest>,
1829        ) -> std::result::Result<
1830            tonic::Response<super::AlterNameResponse>,
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_prost::ProstCodec::default();
1842            let path = http::uri::PathAndQuery::from_static(
1843                "/ddl_service.DdlService/AlterName",
1844            );
1845            let mut req = request.into_request();
1846            req.extensions_mut()
1847                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterName"));
1848            self.inner.unary(req, path, codec).await
1849        }
1850        pub async fn alter_source(
1851            &mut self,
1852            request: impl tonic::IntoRequest<super::AlterSourceRequest>,
1853        ) -> std::result::Result<
1854            tonic::Response<super::AlterSourceResponse>,
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_prost::ProstCodec::default();
1866            let path = http::uri::PathAndQuery::from_static(
1867                "/ddl_service.DdlService/AlterSource",
1868            );
1869            let mut req = request.into_request();
1870            req.extensions_mut()
1871                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSource"));
1872            self.inner.unary(req, path, codec).await
1873        }
1874        pub async fn reset_source(
1875            &mut self,
1876            request: impl tonic::IntoRequest<super::ResetSourceRequest>,
1877        ) -> std::result::Result<
1878            tonic::Response<super::ResetSourceResponse>,
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_prost::ProstCodec::default();
1890            let path = http::uri::PathAndQuery::from_static(
1891                "/ddl_service.DdlService/ResetSource",
1892            );
1893            let mut req = request.into_request();
1894            req.extensions_mut()
1895                .insert(GrpcMethod::new("ddl_service.DdlService", "ResetSource"));
1896            self.inner.unary(req, path, codec).await
1897        }
1898        pub async fn alter_owner(
1899            &mut self,
1900            request: impl tonic::IntoRequest<super::AlterOwnerRequest>,
1901        ) -> std::result::Result<
1902            tonic::Response<super::AlterOwnerResponse>,
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_prost::ProstCodec::default();
1914            let path = http::uri::PathAndQuery::from_static(
1915                "/ddl_service.DdlService/AlterOwner",
1916            );
1917            let mut req = request.into_request();
1918            req.extensions_mut()
1919                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterOwner"));
1920            self.inner.unary(req, path, codec).await
1921        }
1922        pub async fn alter_subscription_retention(
1923            &mut self,
1924            request: impl tonic::IntoRequest<super::AlterSubscriptionRetentionRequest>,
1925        ) -> std::result::Result<
1926            tonic::Response<super::AlterSubscriptionRetentionResponse>,
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_prost::ProstCodec::default();
1938            let path = http::uri::PathAndQuery::from_static(
1939                "/ddl_service.DdlService/AlterSubscriptionRetention",
1940            );
1941            let mut req = request.into_request();
1942            req.extensions_mut()
1943                .insert(
1944                    GrpcMethod::new(
1945                        "ddl_service.DdlService",
1946                        "AlterSubscriptionRetention",
1947                    ),
1948                );
1949            self.inner.unary(req, path, codec).await
1950        }
1951        pub async fn alter_set_schema(
1952            &mut self,
1953            request: impl tonic::IntoRequest<super::AlterSetSchemaRequest>,
1954        ) -> std::result::Result<
1955            tonic::Response<super::AlterSetSchemaResponse>,
1956            tonic::Status,
1957        > {
1958            self.inner
1959                .ready()
1960                .await
1961                .map_err(|e| {
1962                    tonic::Status::unknown(
1963                        format!("Service was not ready: {}", e.into()),
1964                    )
1965                })?;
1966            let codec = tonic_prost::ProstCodec::default();
1967            let path = http::uri::PathAndQuery::from_static(
1968                "/ddl_service.DdlService/AlterSetSchema",
1969            );
1970            let mut req = request.into_request();
1971            req.extensions_mut()
1972                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSetSchema"));
1973            self.inner.unary(req, path, codec).await
1974        }
1975        pub async fn alter_parallelism(
1976            &mut self,
1977            request: impl tonic::IntoRequest<super::AlterParallelismRequest>,
1978        ) -> std::result::Result<
1979            tonic::Response<super::AlterParallelismResponse>,
1980            tonic::Status,
1981        > {
1982            self.inner
1983                .ready()
1984                .await
1985                .map_err(|e| {
1986                    tonic::Status::unknown(
1987                        format!("Service was not ready: {}", e.into()),
1988                    )
1989                })?;
1990            let codec = tonic_prost::ProstCodec::default();
1991            let path = http::uri::PathAndQuery::from_static(
1992                "/ddl_service.DdlService/AlterParallelism",
1993            );
1994            let mut req = request.into_request();
1995            req.extensions_mut()
1996                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterParallelism"));
1997            self.inner.unary(req, path, codec).await
1998        }
1999        pub async fn alter_backfill_parallelism(
2000            &mut self,
2001            request: impl tonic::IntoRequest<super::AlterBackfillParallelismRequest>,
2002        ) -> std::result::Result<
2003            tonic::Response<super::AlterBackfillParallelismResponse>,
2004            tonic::Status,
2005        > {
2006            self.inner
2007                .ready()
2008                .await
2009                .map_err(|e| {
2010                    tonic::Status::unknown(
2011                        format!("Service was not ready: {}", e.into()),
2012                    )
2013                })?;
2014            let codec = tonic_prost::ProstCodec::default();
2015            let path = http::uri::PathAndQuery::from_static(
2016                "/ddl_service.DdlService/AlterBackfillParallelism",
2017            );
2018            let mut req = request.into_request();
2019            req.extensions_mut()
2020                .insert(
2021                    GrpcMethod::new("ddl_service.DdlService", "AlterBackfillParallelism"),
2022                );
2023            self.inner.unary(req, path, codec).await
2024        }
2025        pub async fn alter_fragment_parallelism(
2026            &mut self,
2027            request: impl tonic::IntoRequest<super::AlterFragmentParallelismRequest>,
2028        ) -> std::result::Result<
2029            tonic::Response<super::AlterFragmentParallelismResponse>,
2030            tonic::Status,
2031        > {
2032            self.inner
2033                .ready()
2034                .await
2035                .map_err(|e| {
2036                    tonic::Status::unknown(
2037                        format!("Service was not ready: {}", e.into()),
2038                    )
2039                })?;
2040            let codec = tonic_prost::ProstCodec::default();
2041            let path = http::uri::PathAndQuery::from_static(
2042                "/ddl_service.DdlService/AlterFragmentParallelism",
2043            );
2044            let mut req = request.into_request();
2045            req.extensions_mut()
2046                .insert(
2047                    GrpcMethod::new("ddl_service.DdlService", "AlterFragmentParallelism"),
2048                );
2049            self.inner.unary(req, path, codec).await
2050        }
2051        pub async fn alter_resource_group(
2052            &mut self,
2053            request: impl tonic::IntoRequest<super::AlterResourceGroupRequest>,
2054        ) -> std::result::Result<
2055            tonic::Response<super::AlterResourceGroupResponse>,
2056            tonic::Status,
2057        > {
2058            self.inner
2059                .ready()
2060                .await
2061                .map_err(|e| {
2062                    tonic::Status::unknown(
2063                        format!("Service was not ready: {}", e.into()),
2064                    )
2065                })?;
2066            let codec = tonic_prost::ProstCodec::default();
2067            let path = http::uri::PathAndQuery::from_static(
2068                "/ddl_service.DdlService/AlterResourceGroup",
2069            );
2070            let mut req = request.into_request();
2071            req.extensions_mut()
2072                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterResourceGroup"));
2073            self.inner.unary(req, path, codec).await
2074        }
2075        pub async fn alter_database_resource_group(
2076            &mut self,
2077            request: impl tonic::IntoRequest<super::AlterDatabaseResourceGroupRequest>,
2078        ) -> std::result::Result<
2079            tonic::Response<super::AlterDatabaseResourceGroupResponse>,
2080            tonic::Status,
2081        > {
2082            self.inner
2083                .ready()
2084                .await
2085                .map_err(|e| {
2086                    tonic::Status::unknown(
2087                        format!("Service was not ready: {}", e.into()),
2088                    )
2089                })?;
2090            let codec = tonic_prost::ProstCodec::default();
2091            let path = http::uri::PathAndQuery::from_static(
2092                "/ddl_service.DdlService/AlterDatabaseResourceGroup",
2093            );
2094            let mut req = request.into_request();
2095            req.extensions_mut()
2096                .insert(
2097                    GrpcMethod::new(
2098                        "ddl_service.DdlService",
2099                        "AlterDatabaseResourceGroup",
2100                    ),
2101                );
2102            self.inner.unary(req, path, codec).await
2103        }
2104        pub async fn drop_table(
2105            &mut self,
2106            request: impl tonic::IntoRequest<super::DropTableRequest>,
2107        ) -> std::result::Result<
2108            tonic::Response<super::DropTableResponse>,
2109            tonic::Status,
2110        > {
2111            self.inner
2112                .ready()
2113                .await
2114                .map_err(|e| {
2115                    tonic::Status::unknown(
2116                        format!("Service was not ready: {}", e.into()),
2117                    )
2118                })?;
2119            let codec = tonic_prost::ProstCodec::default();
2120            let path = http::uri::PathAndQuery::from_static(
2121                "/ddl_service.DdlService/DropTable",
2122            );
2123            let mut req = request.into_request();
2124            req.extensions_mut()
2125                .insert(GrpcMethod::new("ddl_service.DdlService", "DropTable"));
2126            self.inner.unary(req, path, codec).await
2127        }
2128        pub async fn risectl_list_state_tables(
2129            &mut self,
2130            request: impl tonic::IntoRequest<super::RisectlListStateTablesRequest>,
2131        ) -> std::result::Result<
2132            tonic::Response<super::RisectlListStateTablesResponse>,
2133            tonic::Status,
2134        > {
2135            self.inner
2136                .ready()
2137                .await
2138                .map_err(|e| {
2139                    tonic::Status::unknown(
2140                        format!("Service was not ready: {}", e.into()),
2141                    )
2142                })?;
2143            let codec = tonic_prost::ProstCodec::default();
2144            let path = http::uri::PathAndQuery::from_static(
2145                "/ddl_service.DdlService/RisectlListStateTables",
2146            );
2147            let mut req = request.into_request();
2148            req.extensions_mut()
2149                .insert(
2150                    GrpcMethod::new("ddl_service.DdlService", "RisectlListStateTables"),
2151                );
2152            self.inner.unary(req, path, codec).await
2153        }
2154        pub async fn risectl_resume_backfill(
2155            &mut self,
2156            request: impl tonic::IntoRequest<super::RisectlResumeBackfillRequest>,
2157        ) -> std::result::Result<
2158            tonic::Response<super::RisectlResumeBackfillResponse>,
2159            tonic::Status,
2160        > {
2161            self.inner
2162                .ready()
2163                .await
2164                .map_err(|e| {
2165                    tonic::Status::unknown(
2166                        format!("Service was not ready: {}", e.into()),
2167                    )
2168                })?;
2169            let codec = tonic_prost::ProstCodec::default();
2170            let path = http::uri::PathAndQuery::from_static(
2171                "/ddl_service.DdlService/RisectlResumeBackfill",
2172            );
2173            let mut req = request.into_request();
2174            req.extensions_mut()
2175                .insert(
2176                    GrpcMethod::new("ddl_service.DdlService", "RisectlResumeBackfill"),
2177                );
2178            self.inner.unary(req, path, codec).await
2179        }
2180        pub async fn create_view(
2181            &mut self,
2182            request: impl tonic::IntoRequest<super::CreateViewRequest>,
2183        ) -> std::result::Result<
2184            tonic::Response<super::CreateViewResponse>,
2185            tonic::Status,
2186        > {
2187            self.inner
2188                .ready()
2189                .await
2190                .map_err(|e| {
2191                    tonic::Status::unknown(
2192                        format!("Service was not ready: {}", e.into()),
2193                    )
2194                })?;
2195            let codec = tonic_prost::ProstCodec::default();
2196            let path = http::uri::PathAndQuery::from_static(
2197                "/ddl_service.DdlService/CreateView",
2198            );
2199            let mut req = request.into_request();
2200            req.extensions_mut()
2201                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateView"));
2202            self.inner.unary(req, path, codec).await
2203        }
2204        pub async fn drop_view(
2205            &mut self,
2206            request: impl tonic::IntoRequest<super::DropViewRequest>,
2207        ) -> std::result::Result<
2208            tonic::Response<super::DropViewResponse>,
2209            tonic::Status,
2210        > {
2211            self.inner
2212                .ready()
2213                .await
2214                .map_err(|e| {
2215                    tonic::Status::unknown(
2216                        format!("Service was not ready: {}", e.into()),
2217                    )
2218                })?;
2219            let codec = tonic_prost::ProstCodec::default();
2220            let path = http::uri::PathAndQuery::from_static(
2221                "/ddl_service.DdlService/DropView",
2222            );
2223            let mut req = request.into_request();
2224            req.extensions_mut()
2225                .insert(GrpcMethod::new("ddl_service.DdlService", "DropView"));
2226            self.inner.unary(req, path, codec).await
2227        }
2228        pub async fn create_index(
2229            &mut self,
2230            request: impl tonic::IntoRequest<super::CreateIndexRequest>,
2231        ) -> std::result::Result<
2232            tonic::Response<super::CreateIndexResponse>,
2233            tonic::Status,
2234        > {
2235            self.inner
2236                .ready()
2237                .await
2238                .map_err(|e| {
2239                    tonic::Status::unknown(
2240                        format!("Service was not ready: {}", e.into()),
2241                    )
2242                })?;
2243            let codec = tonic_prost::ProstCodec::default();
2244            let path = http::uri::PathAndQuery::from_static(
2245                "/ddl_service.DdlService/CreateIndex",
2246            );
2247            let mut req = request.into_request();
2248            req.extensions_mut()
2249                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateIndex"));
2250            self.inner.unary(req, path, codec).await
2251        }
2252        pub async fn drop_index(
2253            &mut self,
2254            request: impl tonic::IntoRequest<super::DropIndexRequest>,
2255        ) -> std::result::Result<
2256            tonic::Response<super::DropIndexResponse>,
2257            tonic::Status,
2258        > {
2259            self.inner
2260                .ready()
2261                .await
2262                .map_err(|e| {
2263                    tonic::Status::unknown(
2264                        format!("Service was not ready: {}", e.into()),
2265                    )
2266                })?;
2267            let codec = tonic_prost::ProstCodec::default();
2268            let path = http::uri::PathAndQuery::from_static(
2269                "/ddl_service.DdlService/DropIndex",
2270            );
2271            let mut req = request.into_request();
2272            req.extensions_mut()
2273                .insert(GrpcMethod::new("ddl_service.DdlService", "DropIndex"));
2274            self.inner.unary(req, path, codec).await
2275        }
2276        pub async fn create_function(
2277            &mut self,
2278            request: impl tonic::IntoRequest<super::CreateFunctionRequest>,
2279        ) -> std::result::Result<
2280            tonic::Response<super::CreateFunctionResponse>,
2281            tonic::Status,
2282        > {
2283            self.inner
2284                .ready()
2285                .await
2286                .map_err(|e| {
2287                    tonic::Status::unknown(
2288                        format!("Service was not ready: {}", e.into()),
2289                    )
2290                })?;
2291            let codec = tonic_prost::ProstCodec::default();
2292            let path = http::uri::PathAndQuery::from_static(
2293                "/ddl_service.DdlService/CreateFunction",
2294            );
2295            let mut req = request.into_request();
2296            req.extensions_mut()
2297                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateFunction"));
2298            self.inner.unary(req, path, codec).await
2299        }
2300        pub async fn drop_function(
2301            &mut self,
2302            request: impl tonic::IntoRequest<super::DropFunctionRequest>,
2303        ) -> std::result::Result<
2304            tonic::Response<super::DropFunctionResponse>,
2305            tonic::Status,
2306        > {
2307            self.inner
2308                .ready()
2309                .await
2310                .map_err(|e| {
2311                    tonic::Status::unknown(
2312                        format!("Service was not ready: {}", e.into()),
2313                    )
2314                })?;
2315            let codec = tonic_prost::ProstCodec::default();
2316            let path = http::uri::PathAndQuery::from_static(
2317                "/ddl_service.DdlService/DropFunction",
2318            );
2319            let mut req = request.into_request();
2320            req.extensions_mut()
2321                .insert(GrpcMethod::new("ddl_service.DdlService", "DropFunction"));
2322            self.inner.unary(req, path, codec).await
2323        }
2324        pub async fn replace_job_plan(
2325            &mut self,
2326            request: impl tonic::IntoRequest<super::ReplaceJobPlanRequest>,
2327        ) -> std::result::Result<
2328            tonic::Response<super::ReplaceJobPlanResponse>,
2329            tonic::Status,
2330        > {
2331            self.inner
2332                .ready()
2333                .await
2334                .map_err(|e| {
2335                    tonic::Status::unknown(
2336                        format!("Service was not ready: {}", e.into()),
2337                    )
2338                })?;
2339            let codec = tonic_prost::ProstCodec::default();
2340            let path = http::uri::PathAndQuery::from_static(
2341                "/ddl_service.DdlService/ReplaceJobPlan",
2342            );
2343            let mut req = request.into_request();
2344            req.extensions_mut()
2345                .insert(GrpcMethod::new("ddl_service.DdlService", "ReplaceJobPlan"));
2346            self.inner.unary(req, path, codec).await
2347        }
2348        pub async fn get_table(
2349            &mut self,
2350            request: impl tonic::IntoRequest<super::GetTableRequest>,
2351        ) -> std::result::Result<
2352            tonic::Response<super::GetTableResponse>,
2353            tonic::Status,
2354        > {
2355            self.inner
2356                .ready()
2357                .await
2358                .map_err(|e| {
2359                    tonic::Status::unknown(
2360                        format!("Service was not ready: {}", e.into()),
2361                    )
2362                })?;
2363            let codec = tonic_prost::ProstCodec::default();
2364            let path = http::uri::PathAndQuery::from_static(
2365                "/ddl_service.DdlService/GetTable",
2366            );
2367            let mut req = request.into_request();
2368            req.extensions_mut()
2369                .insert(GrpcMethod::new("ddl_service.DdlService", "GetTable"));
2370            self.inner.unary(req, path, codec).await
2371        }
2372        pub async fn get_ddl_progress(
2373            &mut self,
2374            request: impl tonic::IntoRequest<super::GetDdlProgressRequest>,
2375        ) -> std::result::Result<
2376            tonic::Response<super::GetDdlProgressResponse>,
2377            tonic::Status,
2378        > {
2379            self.inner
2380                .ready()
2381                .await
2382                .map_err(|e| {
2383                    tonic::Status::unknown(
2384                        format!("Service was not ready: {}", e.into()),
2385                    )
2386                })?;
2387            let codec = tonic_prost::ProstCodec::default();
2388            let path = http::uri::PathAndQuery::from_static(
2389                "/ddl_service.DdlService/GetDdlProgress",
2390            );
2391            let mut req = request.into_request();
2392            req.extensions_mut()
2393                .insert(GrpcMethod::new("ddl_service.DdlService", "GetDdlProgress"));
2394            self.inner.unary(req, path, codec).await
2395        }
2396        pub async fn create_connection(
2397            &mut self,
2398            request: impl tonic::IntoRequest<super::CreateConnectionRequest>,
2399        ) -> std::result::Result<
2400            tonic::Response<super::CreateConnectionResponse>,
2401            tonic::Status,
2402        > {
2403            self.inner
2404                .ready()
2405                .await
2406                .map_err(|e| {
2407                    tonic::Status::unknown(
2408                        format!("Service was not ready: {}", e.into()),
2409                    )
2410                })?;
2411            let codec = tonic_prost::ProstCodec::default();
2412            let path = http::uri::PathAndQuery::from_static(
2413                "/ddl_service.DdlService/CreateConnection",
2414            );
2415            let mut req = request.into_request();
2416            req.extensions_mut()
2417                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateConnection"));
2418            self.inner.unary(req, path, codec).await
2419        }
2420        pub async fn list_connections(
2421            &mut self,
2422            request: impl tonic::IntoRequest<super::ListConnectionsRequest>,
2423        ) -> std::result::Result<
2424            tonic::Response<super::ListConnectionsResponse>,
2425            tonic::Status,
2426        > {
2427            self.inner
2428                .ready()
2429                .await
2430                .map_err(|e| {
2431                    tonic::Status::unknown(
2432                        format!("Service was not ready: {}", e.into()),
2433                    )
2434                })?;
2435            let codec = tonic_prost::ProstCodec::default();
2436            let path = http::uri::PathAndQuery::from_static(
2437                "/ddl_service.DdlService/ListConnections",
2438            );
2439            let mut req = request.into_request();
2440            req.extensions_mut()
2441                .insert(GrpcMethod::new("ddl_service.DdlService", "ListConnections"));
2442            self.inner.unary(req, path, codec).await
2443        }
2444        pub async fn drop_connection(
2445            &mut self,
2446            request: impl tonic::IntoRequest<super::DropConnectionRequest>,
2447        ) -> std::result::Result<
2448            tonic::Response<super::DropConnectionResponse>,
2449            tonic::Status,
2450        > {
2451            self.inner
2452                .ready()
2453                .await
2454                .map_err(|e| {
2455                    tonic::Status::unknown(
2456                        format!("Service was not ready: {}", e.into()),
2457                    )
2458                })?;
2459            let codec = tonic_prost::ProstCodec::default();
2460            let path = http::uri::PathAndQuery::from_static(
2461                "/ddl_service.DdlService/DropConnection",
2462            );
2463            let mut req = request.into_request();
2464            req.extensions_mut()
2465                .insert(GrpcMethod::new("ddl_service.DdlService", "DropConnection"));
2466            self.inner.unary(req, path, codec).await
2467        }
2468        pub async fn get_tables(
2469            &mut self,
2470            request: impl tonic::IntoRequest<super::GetTablesRequest>,
2471        ) -> std::result::Result<
2472            tonic::Response<super::GetTablesResponse>,
2473            tonic::Status,
2474        > {
2475            self.inner
2476                .ready()
2477                .await
2478                .map_err(|e| {
2479                    tonic::Status::unknown(
2480                        format!("Service was not ready: {}", e.into()),
2481                    )
2482                })?;
2483            let codec = tonic_prost::ProstCodec::default();
2484            let path = http::uri::PathAndQuery::from_static(
2485                "/ddl_service.DdlService/GetTables",
2486            );
2487            let mut req = request.into_request();
2488            req.extensions_mut()
2489                .insert(GrpcMethod::new("ddl_service.DdlService", "GetTables"));
2490            self.inner.unary(req, path, codec).await
2491        }
2492        pub async fn wait(
2493            &mut self,
2494            request: impl tonic::IntoRequest<super::WaitRequest>,
2495        ) -> std::result::Result<tonic::Response<super::WaitResponse>, tonic::Status> {
2496            self.inner
2497                .ready()
2498                .await
2499                .map_err(|e| {
2500                    tonic::Status::unknown(
2501                        format!("Service was not ready: {}", e.into()),
2502                    )
2503                })?;
2504            let codec = tonic_prost::ProstCodec::default();
2505            let path = http::uri::PathAndQuery::from_static(
2506                "/ddl_service.DdlService/Wait",
2507            );
2508            let mut req = request.into_request();
2509            req.extensions_mut()
2510                .insert(GrpcMethod::new("ddl_service.DdlService", "Wait"));
2511            self.inner.unary(req, path, codec).await
2512        }
2513        pub async fn comment_on(
2514            &mut self,
2515            request: impl tonic::IntoRequest<super::CommentOnRequest>,
2516        ) -> std::result::Result<
2517            tonic::Response<super::CommentOnResponse>,
2518            tonic::Status,
2519        > {
2520            self.inner
2521                .ready()
2522                .await
2523                .map_err(|e| {
2524                    tonic::Status::unknown(
2525                        format!("Service was not ready: {}", e.into()),
2526                    )
2527                })?;
2528            let codec = tonic_prost::ProstCodec::default();
2529            let path = http::uri::PathAndQuery::from_static(
2530                "/ddl_service.DdlService/CommentOn",
2531            );
2532            let mut req = request.into_request();
2533            req.extensions_mut()
2534                .insert(GrpcMethod::new("ddl_service.DdlService", "CommentOn"));
2535            self.inner.unary(req, path, codec).await
2536        }
2537        pub async fn auto_schema_change(
2538            &mut self,
2539            request: impl tonic::IntoRequest<super::AutoSchemaChangeRequest>,
2540        ) -> std::result::Result<
2541            tonic::Response<super::AutoSchemaChangeResponse>,
2542            tonic::Status,
2543        > {
2544            self.inner
2545                .ready()
2546                .await
2547                .map_err(|e| {
2548                    tonic::Status::unknown(
2549                        format!("Service was not ready: {}", e.into()),
2550                    )
2551                })?;
2552            let codec = tonic_prost::ProstCodec::default();
2553            let path = http::uri::PathAndQuery::from_static(
2554                "/ddl_service.DdlService/AutoSchemaChange",
2555            );
2556            let mut req = request.into_request();
2557            req.extensions_mut()
2558                .insert(GrpcMethod::new("ddl_service.DdlService", "AutoSchemaChange"));
2559            self.inner.unary(req, path, codec).await
2560        }
2561        pub async fn alter_swap_rename(
2562            &mut self,
2563            request: impl tonic::IntoRequest<super::AlterSwapRenameRequest>,
2564        ) -> std::result::Result<
2565            tonic::Response<super::AlterSwapRenameResponse>,
2566            tonic::Status,
2567        > {
2568            self.inner
2569                .ready()
2570                .await
2571                .map_err(|e| {
2572                    tonic::Status::unknown(
2573                        format!("Service was not ready: {}", e.into()),
2574                    )
2575                })?;
2576            let codec = tonic_prost::ProstCodec::default();
2577            let path = http::uri::PathAndQuery::from_static(
2578                "/ddl_service.DdlService/AlterSwapRename",
2579            );
2580            let mut req = request.into_request();
2581            req.extensions_mut()
2582                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSwapRename"));
2583            self.inner.unary(req, path, codec).await
2584        }
2585        pub async fn alter_database_param(
2586            &mut self,
2587            request: impl tonic::IntoRequest<super::AlterDatabaseParamRequest>,
2588        ) -> std::result::Result<
2589            tonic::Response<super::AlterDatabaseParamResponse>,
2590            tonic::Status,
2591        > {
2592            self.inner
2593                .ready()
2594                .await
2595                .map_err(|e| {
2596                    tonic::Status::unknown(
2597                        format!("Service was not ready: {}", e.into()),
2598                    )
2599                })?;
2600            let codec = tonic_prost::ProstCodec::default();
2601            let path = http::uri::PathAndQuery::from_static(
2602                "/ddl_service.DdlService/AlterDatabaseParam",
2603            );
2604            let mut req = request.into_request();
2605            req.extensions_mut()
2606                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterDatabaseParam"));
2607            self.inner.unary(req, path, codec).await
2608        }
2609        pub async fn compact_iceberg_table(
2610            &mut self,
2611            request: impl tonic::IntoRequest<super::CompactIcebergTableRequest>,
2612        ) -> std::result::Result<
2613            tonic::Response<super::CompactIcebergTableResponse>,
2614            tonic::Status,
2615        > {
2616            self.inner
2617                .ready()
2618                .await
2619                .map_err(|e| {
2620                    tonic::Status::unknown(
2621                        format!("Service was not ready: {}", e.into()),
2622                    )
2623                })?;
2624            let codec = tonic_prost::ProstCodec::default();
2625            let path = http::uri::PathAndQuery::from_static(
2626                "/ddl_service.DdlService/CompactIcebergTable",
2627            );
2628            let mut req = request.into_request();
2629            req.extensions_mut()
2630                .insert(
2631                    GrpcMethod::new("ddl_service.DdlService", "CompactIcebergTable"),
2632                );
2633            self.inner.unary(req, path, codec).await
2634        }
2635        pub async fn rewrite_iceberg_table_manifests(
2636            &mut self,
2637            request: impl tonic::IntoRequest<super::RewriteIcebergTableManifestsRequest>,
2638        ) -> std::result::Result<
2639            tonic::Response<super::RewriteIcebergTableManifestsResponse>,
2640            tonic::Status,
2641        > {
2642            self.inner
2643                .ready()
2644                .await
2645                .map_err(|e| {
2646                    tonic::Status::unknown(
2647                        format!("Service was not ready: {}", e.into()),
2648                    )
2649                })?;
2650            let codec = tonic_prost::ProstCodec::default();
2651            let path = http::uri::PathAndQuery::from_static(
2652                "/ddl_service.DdlService/RewriteIcebergTableManifests",
2653            );
2654            let mut req = request.into_request();
2655            req.extensions_mut()
2656                .insert(
2657                    GrpcMethod::new(
2658                        "ddl_service.DdlService",
2659                        "RewriteIcebergTableManifests",
2660                    ),
2661                );
2662            self.inner.unary(req, path, codec).await
2663        }
2664        pub async fn expire_iceberg_table_snapshots(
2665            &mut self,
2666            request: impl tonic::IntoRequest<super::ExpireIcebergTableSnapshotsRequest>,
2667        ) -> std::result::Result<
2668            tonic::Response<super::ExpireIcebergTableSnapshotsResponse>,
2669            tonic::Status,
2670        > {
2671            self.inner
2672                .ready()
2673                .await
2674                .map_err(|e| {
2675                    tonic::Status::unknown(
2676                        format!("Service was not ready: {}", e.into()),
2677                    )
2678                })?;
2679            let codec = tonic_prost::ProstCodec::default();
2680            let path = http::uri::PathAndQuery::from_static(
2681                "/ddl_service.DdlService/ExpireIcebergTableSnapshots",
2682            );
2683            let mut req = request.into_request();
2684            req.extensions_mut()
2685                .insert(
2686                    GrpcMethod::new(
2687                        "ddl_service.DdlService",
2688                        "ExpireIcebergTableSnapshots",
2689                    ),
2690                );
2691            self.inner.unary(req, path, codec).await
2692        }
2693        pub async fn remove_iceberg_table_orphan_files(
2694            &mut self,
2695            request: impl tonic::IntoRequest<super::RemoveIcebergTableOrphanFilesRequest>,
2696        ) -> std::result::Result<
2697            tonic::Response<super::RemoveIcebergTableOrphanFilesResponse>,
2698            tonic::Status,
2699        > {
2700            self.inner
2701                .ready()
2702                .await
2703                .map_err(|e| {
2704                    tonic::Status::unknown(
2705                        format!("Service was not ready: {}", e.into()),
2706                    )
2707                })?;
2708            let codec = tonic_prost::ProstCodec::default();
2709            let path = http::uri::PathAndQuery::from_static(
2710                "/ddl_service.DdlService/RemoveIcebergTableOrphanFiles",
2711            );
2712            let mut req = request.into_request();
2713            req.extensions_mut()
2714                .insert(
2715                    GrpcMethod::new(
2716                        "ddl_service.DdlService",
2717                        "RemoveIcebergTableOrphanFiles",
2718                    ),
2719                );
2720            self.inner.unary(req, path, codec).await
2721        }
2722        pub async fn alter_cdc_table_backfill_parallelism(
2723            &mut self,
2724            request: impl tonic::IntoRequest<
2725                super::AlterCdcTableBackfillParallelismRequest,
2726            >,
2727        ) -> std::result::Result<
2728            tonic::Response<super::AlterCdcTableBackfillParallelismResponse>,
2729            tonic::Status,
2730        > {
2731            self.inner
2732                .ready()
2733                .await
2734                .map_err(|e| {
2735                    tonic::Status::unknown(
2736                        format!("Service was not ready: {}", e.into()),
2737                    )
2738                })?;
2739            let codec = tonic_prost::ProstCodec::default();
2740            let path = http::uri::PathAndQuery::from_static(
2741                "/ddl_service.DdlService/AlterCdcTableBackfillParallelism",
2742            );
2743            let mut req = request.into_request();
2744            req.extensions_mut()
2745                .insert(
2746                    GrpcMethod::new(
2747                        "ddl_service.DdlService",
2748                        "AlterCdcTableBackfillParallelism",
2749                    ),
2750                );
2751            self.inner.unary(req, path, codec).await
2752        }
2753        pub async fn alter_streaming_job_config(
2754            &mut self,
2755            request: impl tonic::IntoRequest<super::AlterStreamingJobConfigRequest>,
2756        ) -> std::result::Result<
2757            tonic::Response<super::AlterStreamingJobConfigResponse>,
2758            tonic::Status,
2759        > {
2760            self.inner
2761                .ready()
2762                .await
2763                .map_err(|e| {
2764                    tonic::Status::unknown(
2765                        format!("Service was not ready: {}", e.into()),
2766                    )
2767                })?;
2768            let codec = tonic_prost::ProstCodec::default();
2769            let path = http::uri::PathAndQuery::from_static(
2770                "/ddl_service.DdlService/AlterStreamingJobConfig",
2771            );
2772            let mut req = request.into_request();
2773            req.extensions_mut()
2774                .insert(
2775                    GrpcMethod::new("ddl_service.DdlService", "AlterStreamingJobConfig"),
2776                );
2777            self.inner.unary(req, path, codec).await
2778        }
2779        pub async fn wait_iceberg_pk_index_sink_epoch(
2780            &mut self,
2781            request: impl tonic::IntoRequest<super::WaitIcebergPkIndexSinkEpochRequest>,
2782        ) -> std::result::Result<
2783            tonic::Response<super::WaitIcebergPkIndexSinkEpochResponse>,
2784            tonic::Status,
2785        > {
2786            self.inner
2787                .ready()
2788                .await
2789                .map_err(|e| {
2790                    tonic::Status::unknown(
2791                        format!("Service was not ready: {}", e.into()),
2792                    )
2793                })?;
2794            let codec = tonic_prost::ProstCodec::default();
2795            let path = http::uri::PathAndQuery::from_static(
2796                "/ddl_service.DdlService/WaitIcebergPkIndexSinkEpoch",
2797            );
2798            let mut req = request.into_request();
2799            req.extensions_mut()
2800                .insert(
2801                    GrpcMethod::new(
2802                        "ddl_service.DdlService",
2803                        "WaitIcebergPkIndexSinkEpoch",
2804                    ),
2805                );
2806            self.inner.unary(req, path, codec).await
2807        }
2808    }
2809}
2810/// Generated server implementations.
2811pub mod ddl_service_server {
2812    #![allow(
2813        unused_variables,
2814        dead_code,
2815        missing_docs,
2816        clippy::wildcard_imports,
2817        clippy::let_unit_value,
2818    )]
2819    use tonic::codegen::*;
2820    /// Generated trait containing gRPC methods that should be implemented for use with DdlServiceServer.
2821    #[async_trait]
2822    pub trait DdlService: std::marker::Send + std::marker::Sync + 'static {
2823        async fn create_database(
2824            &self,
2825            request: tonic::Request<super::CreateDatabaseRequest>,
2826        ) -> std::result::Result<
2827            tonic::Response<super::CreateDatabaseResponse>,
2828            tonic::Status,
2829        >;
2830        async fn drop_database(
2831            &self,
2832            request: tonic::Request<super::DropDatabaseRequest>,
2833        ) -> std::result::Result<
2834            tonic::Response<super::DropDatabaseResponse>,
2835            tonic::Status,
2836        >;
2837        async fn create_schema(
2838            &self,
2839            request: tonic::Request<super::CreateSchemaRequest>,
2840        ) -> std::result::Result<
2841            tonic::Response<super::CreateSchemaResponse>,
2842            tonic::Status,
2843        >;
2844        async fn drop_schema(
2845            &self,
2846            request: tonic::Request<super::DropSchemaRequest>,
2847        ) -> std::result::Result<
2848            tonic::Response<super::DropSchemaResponse>,
2849            tonic::Status,
2850        >;
2851        async fn create_source(
2852            &self,
2853            request: tonic::Request<super::CreateSourceRequest>,
2854        ) -> std::result::Result<
2855            tonic::Response<super::CreateSourceResponse>,
2856            tonic::Status,
2857        >;
2858        async fn drop_source(
2859            &self,
2860            request: tonic::Request<super::DropSourceRequest>,
2861        ) -> std::result::Result<
2862            tonic::Response<super::DropSourceResponse>,
2863            tonic::Status,
2864        >;
2865        async fn create_sink(
2866            &self,
2867            request: tonic::Request<super::CreateSinkRequest>,
2868        ) -> std::result::Result<
2869            tonic::Response<super::CreateSinkResponse>,
2870            tonic::Status,
2871        >;
2872        async fn create_subscription(
2873            &self,
2874            request: tonic::Request<super::CreateSubscriptionRequest>,
2875        ) -> std::result::Result<
2876            tonic::Response<super::CreateSubscriptionResponse>,
2877            tonic::Status,
2878        >;
2879        async fn drop_sink(
2880            &self,
2881            request: tonic::Request<super::DropSinkRequest>,
2882        ) -> std::result::Result<
2883            tonic::Response<super::DropSinkResponse>,
2884            tonic::Status,
2885        >;
2886        async fn drop_subscription(
2887            &self,
2888            request: tonic::Request<super::DropSubscriptionRequest>,
2889        ) -> std::result::Result<
2890            tonic::Response<super::DropSubscriptionResponse>,
2891            tonic::Status,
2892        >;
2893        async fn create_materialized_view(
2894            &self,
2895            request: tonic::Request<super::CreateMaterializedViewRequest>,
2896        ) -> std::result::Result<
2897            tonic::Response<super::CreateMaterializedViewResponse>,
2898            tonic::Status,
2899        >;
2900        async fn drop_materialized_view(
2901            &self,
2902            request: tonic::Request<super::DropMaterializedViewRequest>,
2903        ) -> std::result::Result<
2904            tonic::Response<super::DropMaterializedViewResponse>,
2905            tonic::Status,
2906        >;
2907        async fn create_table(
2908            &self,
2909            request: tonic::Request<super::CreateTableRequest>,
2910        ) -> std::result::Result<
2911            tonic::Response<super::CreateTableResponse>,
2912            tonic::Status,
2913        >;
2914        async fn create_iceberg_table(
2915            &self,
2916            request: tonic::Request<super::CreateIcebergTableRequest>,
2917        ) -> std::result::Result<
2918            tonic::Response<super::CreateIcebergTableResponse>,
2919            tonic::Status,
2920        >;
2921        async fn create_secret(
2922            &self,
2923            request: tonic::Request<super::CreateSecretRequest>,
2924        ) -> std::result::Result<
2925            tonic::Response<super::CreateSecretResponse>,
2926            tonic::Status,
2927        >;
2928        async fn drop_secret(
2929            &self,
2930            request: tonic::Request<super::DropSecretRequest>,
2931        ) -> std::result::Result<
2932            tonic::Response<super::DropSecretResponse>,
2933            tonic::Status,
2934        >;
2935        async fn alter_secret(
2936            &self,
2937            request: tonic::Request<super::AlterSecretRequest>,
2938        ) -> std::result::Result<
2939            tonic::Response<super::AlterSecretResponse>,
2940            tonic::Status,
2941        >;
2942        async fn alter_name(
2943            &self,
2944            request: tonic::Request<super::AlterNameRequest>,
2945        ) -> std::result::Result<
2946            tonic::Response<super::AlterNameResponse>,
2947            tonic::Status,
2948        >;
2949        async fn alter_source(
2950            &self,
2951            request: tonic::Request<super::AlterSourceRequest>,
2952        ) -> std::result::Result<
2953            tonic::Response<super::AlterSourceResponse>,
2954            tonic::Status,
2955        >;
2956        async fn reset_source(
2957            &self,
2958            request: tonic::Request<super::ResetSourceRequest>,
2959        ) -> std::result::Result<
2960            tonic::Response<super::ResetSourceResponse>,
2961            tonic::Status,
2962        >;
2963        async fn alter_owner(
2964            &self,
2965            request: tonic::Request<super::AlterOwnerRequest>,
2966        ) -> std::result::Result<
2967            tonic::Response<super::AlterOwnerResponse>,
2968            tonic::Status,
2969        >;
2970        async fn alter_subscription_retention(
2971            &self,
2972            request: tonic::Request<super::AlterSubscriptionRetentionRequest>,
2973        ) -> std::result::Result<
2974            tonic::Response<super::AlterSubscriptionRetentionResponse>,
2975            tonic::Status,
2976        >;
2977        async fn alter_set_schema(
2978            &self,
2979            request: tonic::Request<super::AlterSetSchemaRequest>,
2980        ) -> std::result::Result<
2981            tonic::Response<super::AlterSetSchemaResponse>,
2982            tonic::Status,
2983        >;
2984        async fn alter_parallelism(
2985            &self,
2986            request: tonic::Request<super::AlterParallelismRequest>,
2987        ) -> std::result::Result<
2988            tonic::Response<super::AlterParallelismResponse>,
2989            tonic::Status,
2990        >;
2991        async fn alter_backfill_parallelism(
2992            &self,
2993            request: tonic::Request<super::AlterBackfillParallelismRequest>,
2994        ) -> std::result::Result<
2995            tonic::Response<super::AlterBackfillParallelismResponse>,
2996            tonic::Status,
2997        >;
2998        async fn alter_fragment_parallelism(
2999            &self,
3000            request: tonic::Request<super::AlterFragmentParallelismRequest>,
3001        ) -> std::result::Result<
3002            tonic::Response<super::AlterFragmentParallelismResponse>,
3003            tonic::Status,
3004        >;
3005        async fn alter_resource_group(
3006            &self,
3007            request: tonic::Request<super::AlterResourceGroupRequest>,
3008        ) -> std::result::Result<
3009            tonic::Response<super::AlterResourceGroupResponse>,
3010            tonic::Status,
3011        >;
3012        async fn alter_database_resource_group(
3013            &self,
3014            request: tonic::Request<super::AlterDatabaseResourceGroupRequest>,
3015        ) -> std::result::Result<
3016            tonic::Response<super::AlterDatabaseResourceGroupResponse>,
3017            tonic::Status,
3018        >;
3019        async fn drop_table(
3020            &self,
3021            request: tonic::Request<super::DropTableRequest>,
3022        ) -> std::result::Result<
3023            tonic::Response<super::DropTableResponse>,
3024            tonic::Status,
3025        >;
3026        async fn risectl_list_state_tables(
3027            &self,
3028            request: tonic::Request<super::RisectlListStateTablesRequest>,
3029        ) -> std::result::Result<
3030            tonic::Response<super::RisectlListStateTablesResponse>,
3031            tonic::Status,
3032        >;
3033        async fn risectl_resume_backfill(
3034            &self,
3035            request: tonic::Request<super::RisectlResumeBackfillRequest>,
3036        ) -> std::result::Result<
3037            tonic::Response<super::RisectlResumeBackfillResponse>,
3038            tonic::Status,
3039        >;
3040        async fn create_view(
3041            &self,
3042            request: tonic::Request<super::CreateViewRequest>,
3043        ) -> std::result::Result<
3044            tonic::Response<super::CreateViewResponse>,
3045            tonic::Status,
3046        >;
3047        async fn drop_view(
3048            &self,
3049            request: tonic::Request<super::DropViewRequest>,
3050        ) -> std::result::Result<
3051            tonic::Response<super::DropViewResponse>,
3052            tonic::Status,
3053        >;
3054        async fn create_index(
3055            &self,
3056            request: tonic::Request<super::CreateIndexRequest>,
3057        ) -> std::result::Result<
3058            tonic::Response<super::CreateIndexResponse>,
3059            tonic::Status,
3060        >;
3061        async fn drop_index(
3062            &self,
3063            request: tonic::Request<super::DropIndexRequest>,
3064        ) -> std::result::Result<
3065            tonic::Response<super::DropIndexResponse>,
3066            tonic::Status,
3067        >;
3068        async fn create_function(
3069            &self,
3070            request: tonic::Request<super::CreateFunctionRequest>,
3071        ) -> std::result::Result<
3072            tonic::Response<super::CreateFunctionResponse>,
3073            tonic::Status,
3074        >;
3075        async fn drop_function(
3076            &self,
3077            request: tonic::Request<super::DropFunctionRequest>,
3078        ) -> std::result::Result<
3079            tonic::Response<super::DropFunctionResponse>,
3080            tonic::Status,
3081        >;
3082        async fn replace_job_plan(
3083            &self,
3084            request: tonic::Request<super::ReplaceJobPlanRequest>,
3085        ) -> std::result::Result<
3086            tonic::Response<super::ReplaceJobPlanResponse>,
3087            tonic::Status,
3088        >;
3089        async fn get_table(
3090            &self,
3091            request: tonic::Request<super::GetTableRequest>,
3092        ) -> std::result::Result<
3093            tonic::Response<super::GetTableResponse>,
3094            tonic::Status,
3095        >;
3096        async fn get_ddl_progress(
3097            &self,
3098            request: tonic::Request<super::GetDdlProgressRequest>,
3099        ) -> std::result::Result<
3100            tonic::Response<super::GetDdlProgressResponse>,
3101            tonic::Status,
3102        >;
3103        async fn create_connection(
3104            &self,
3105            request: tonic::Request<super::CreateConnectionRequest>,
3106        ) -> std::result::Result<
3107            tonic::Response<super::CreateConnectionResponse>,
3108            tonic::Status,
3109        >;
3110        async fn list_connections(
3111            &self,
3112            request: tonic::Request<super::ListConnectionsRequest>,
3113        ) -> std::result::Result<
3114            tonic::Response<super::ListConnectionsResponse>,
3115            tonic::Status,
3116        >;
3117        async fn drop_connection(
3118            &self,
3119            request: tonic::Request<super::DropConnectionRequest>,
3120        ) -> std::result::Result<
3121            tonic::Response<super::DropConnectionResponse>,
3122            tonic::Status,
3123        >;
3124        async fn get_tables(
3125            &self,
3126            request: tonic::Request<super::GetTablesRequest>,
3127        ) -> std::result::Result<
3128            tonic::Response<super::GetTablesResponse>,
3129            tonic::Status,
3130        >;
3131        async fn wait(
3132            &self,
3133            request: tonic::Request<super::WaitRequest>,
3134        ) -> std::result::Result<tonic::Response<super::WaitResponse>, tonic::Status>;
3135        async fn comment_on(
3136            &self,
3137            request: tonic::Request<super::CommentOnRequest>,
3138        ) -> std::result::Result<
3139            tonic::Response<super::CommentOnResponse>,
3140            tonic::Status,
3141        >;
3142        async fn auto_schema_change(
3143            &self,
3144            request: tonic::Request<super::AutoSchemaChangeRequest>,
3145        ) -> std::result::Result<
3146            tonic::Response<super::AutoSchemaChangeResponse>,
3147            tonic::Status,
3148        >;
3149        async fn alter_swap_rename(
3150            &self,
3151            request: tonic::Request<super::AlterSwapRenameRequest>,
3152        ) -> std::result::Result<
3153            tonic::Response<super::AlterSwapRenameResponse>,
3154            tonic::Status,
3155        >;
3156        async fn alter_database_param(
3157            &self,
3158            request: tonic::Request<super::AlterDatabaseParamRequest>,
3159        ) -> std::result::Result<
3160            tonic::Response<super::AlterDatabaseParamResponse>,
3161            tonic::Status,
3162        >;
3163        async fn compact_iceberg_table(
3164            &self,
3165            request: tonic::Request<super::CompactIcebergTableRequest>,
3166        ) -> std::result::Result<
3167            tonic::Response<super::CompactIcebergTableResponse>,
3168            tonic::Status,
3169        >;
3170        async fn rewrite_iceberg_table_manifests(
3171            &self,
3172            request: tonic::Request<super::RewriteIcebergTableManifestsRequest>,
3173        ) -> std::result::Result<
3174            tonic::Response<super::RewriteIcebergTableManifestsResponse>,
3175            tonic::Status,
3176        >;
3177        async fn expire_iceberg_table_snapshots(
3178            &self,
3179            request: tonic::Request<super::ExpireIcebergTableSnapshotsRequest>,
3180        ) -> std::result::Result<
3181            tonic::Response<super::ExpireIcebergTableSnapshotsResponse>,
3182            tonic::Status,
3183        >;
3184        async fn remove_iceberg_table_orphan_files(
3185            &self,
3186            request: tonic::Request<super::RemoveIcebergTableOrphanFilesRequest>,
3187        ) -> std::result::Result<
3188            tonic::Response<super::RemoveIcebergTableOrphanFilesResponse>,
3189            tonic::Status,
3190        >;
3191        async fn alter_cdc_table_backfill_parallelism(
3192            &self,
3193            request: tonic::Request<super::AlterCdcTableBackfillParallelismRequest>,
3194        ) -> std::result::Result<
3195            tonic::Response<super::AlterCdcTableBackfillParallelismResponse>,
3196            tonic::Status,
3197        >;
3198        async fn alter_streaming_job_config(
3199            &self,
3200            request: tonic::Request<super::AlterStreamingJobConfigRequest>,
3201        ) -> std::result::Result<
3202            tonic::Response<super::AlterStreamingJobConfigResponse>,
3203            tonic::Status,
3204        >;
3205        async fn wait_iceberg_pk_index_sink_epoch(
3206            &self,
3207            request: tonic::Request<super::WaitIcebergPkIndexSinkEpochRequest>,
3208        ) -> std::result::Result<
3209            tonic::Response<super::WaitIcebergPkIndexSinkEpochResponse>,
3210            tonic::Status,
3211        >;
3212    }
3213    #[derive(Debug)]
3214    pub struct DdlServiceServer<T> {
3215        inner: Arc<T>,
3216        accept_compression_encodings: EnabledCompressionEncodings,
3217        send_compression_encodings: EnabledCompressionEncodings,
3218        max_decoding_message_size: Option<usize>,
3219        max_encoding_message_size: Option<usize>,
3220    }
3221    impl<T> DdlServiceServer<T> {
3222        pub fn new(inner: T) -> Self {
3223            Self::from_arc(Arc::new(inner))
3224        }
3225        pub fn from_arc(inner: Arc<T>) -> Self {
3226            Self {
3227                inner,
3228                accept_compression_encodings: Default::default(),
3229                send_compression_encodings: Default::default(),
3230                max_decoding_message_size: None,
3231                max_encoding_message_size: None,
3232            }
3233        }
3234        pub fn with_interceptor<F>(
3235            inner: T,
3236            interceptor: F,
3237        ) -> InterceptedService<Self, F>
3238        where
3239            F: tonic::service::Interceptor,
3240        {
3241            InterceptedService::new(Self::new(inner), interceptor)
3242        }
3243        /// Enable decompressing requests with the given encoding.
3244        #[must_use]
3245        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
3246            self.accept_compression_encodings.enable(encoding);
3247            self
3248        }
3249        /// Compress responses with the given encoding, if the client supports it.
3250        #[must_use]
3251        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
3252            self.send_compression_encodings.enable(encoding);
3253            self
3254        }
3255        /// Limits the maximum size of a decoded message.
3256        ///
3257        /// Default: `4MB`
3258        #[must_use]
3259        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
3260            self.max_decoding_message_size = Some(limit);
3261            self
3262        }
3263        /// Limits the maximum size of an encoded message.
3264        ///
3265        /// Default: `usize::MAX`
3266        #[must_use]
3267        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
3268            self.max_encoding_message_size = Some(limit);
3269            self
3270        }
3271    }
3272    impl<T, B> tonic::codegen::Service<http::Request<B>> for DdlServiceServer<T>
3273    where
3274        T: DdlService,
3275        B: Body + std::marker::Send + 'static,
3276        B::Error: Into<StdError> + std::marker::Send + 'static,
3277    {
3278        type Response = http::Response<tonic::body::Body>;
3279        type Error = std::convert::Infallible;
3280        type Future = BoxFuture<Self::Response, Self::Error>;
3281        fn poll_ready(
3282            &mut self,
3283            _cx: &mut Context<'_>,
3284        ) -> Poll<std::result::Result<(), Self::Error>> {
3285            Poll::Ready(Ok(()))
3286        }
3287        fn call(&mut self, req: http::Request<B>) -> Self::Future {
3288            match req.uri().path() {
3289                "/ddl_service.DdlService/CreateDatabase" => {
3290                    #[allow(non_camel_case_types)]
3291                    struct CreateDatabaseSvc<T: DdlService>(pub Arc<T>);
3292                    impl<
3293                        T: DdlService,
3294                    > tonic::server::UnaryService<super::CreateDatabaseRequest>
3295                    for CreateDatabaseSvc<T> {
3296                        type Response = super::CreateDatabaseResponse;
3297                        type Future = BoxFuture<
3298                            tonic::Response<Self::Response>,
3299                            tonic::Status,
3300                        >;
3301                        fn call(
3302                            &mut self,
3303                            request: tonic::Request<super::CreateDatabaseRequest>,
3304                        ) -> Self::Future {
3305                            let inner = Arc::clone(&self.0);
3306                            let fut = async move {
3307                                <T as DdlService>::create_database(&inner, request).await
3308                            };
3309                            Box::pin(fut)
3310                        }
3311                    }
3312                    let accept_compression_encodings = self.accept_compression_encodings;
3313                    let send_compression_encodings = self.send_compression_encodings;
3314                    let max_decoding_message_size = self.max_decoding_message_size;
3315                    let max_encoding_message_size = self.max_encoding_message_size;
3316                    let inner = self.inner.clone();
3317                    let fut = async move {
3318                        let method = CreateDatabaseSvc(inner);
3319                        let codec = tonic_prost::ProstCodec::default();
3320                        let mut grpc = tonic::server::Grpc::new(codec)
3321                            .apply_compression_config(
3322                                accept_compression_encodings,
3323                                send_compression_encodings,
3324                            )
3325                            .apply_max_message_size_config(
3326                                max_decoding_message_size,
3327                                max_encoding_message_size,
3328                            );
3329                        let res = grpc.unary(method, req).await;
3330                        Ok(res)
3331                    };
3332                    Box::pin(fut)
3333                }
3334                "/ddl_service.DdlService/DropDatabase" => {
3335                    #[allow(non_camel_case_types)]
3336                    struct DropDatabaseSvc<T: DdlService>(pub Arc<T>);
3337                    impl<
3338                        T: DdlService,
3339                    > tonic::server::UnaryService<super::DropDatabaseRequest>
3340                    for DropDatabaseSvc<T> {
3341                        type Response = super::DropDatabaseResponse;
3342                        type Future = BoxFuture<
3343                            tonic::Response<Self::Response>,
3344                            tonic::Status,
3345                        >;
3346                        fn call(
3347                            &mut self,
3348                            request: tonic::Request<super::DropDatabaseRequest>,
3349                        ) -> Self::Future {
3350                            let inner = Arc::clone(&self.0);
3351                            let fut = async move {
3352                                <T as DdlService>::drop_database(&inner, request).await
3353                            };
3354                            Box::pin(fut)
3355                        }
3356                    }
3357                    let accept_compression_encodings = self.accept_compression_encodings;
3358                    let send_compression_encodings = self.send_compression_encodings;
3359                    let max_decoding_message_size = self.max_decoding_message_size;
3360                    let max_encoding_message_size = self.max_encoding_message_size;
3361                    let inner = self.inner.clone();
3362                    let fut = async move {
3363                        let method = DropDatabaseSvc(inner);
3364                        let codec = tonic_prost::ProstCodec::default();
3365                        let mut grpc = tonic::server::Grpc::new(codec)
3366                            .apply_compression_config(
3367                                accept_compression_encodings,
3368                                send_compression_encodings,
3369                            )
3370                            .apply_max_message_size_config(
3371                                max_decoding_message_size,
3372                                max_encoding_message_size,
3373                            );
3374                        let res = grpc.unary(method, req).await;
3375                        Ok(res)
3376                    };
3377                    Box::pin(fut)
3378                }
3379                "/ddl_service.DdlService/CreateSchema" => {
3380                    #[allow(non_camel_case_types)]
3381                    struct CreateSchemaSvc<T: DdlService>(pub Arc<T>);
3382                    impl<
3383                        T: DdlService,
3384                    > tonic::server::UnaryService<super::CreateSchemaRequest>
3385                    for CreateSchemaSvc<T> {
3386                        type Response = super::CreateSchemaResponse;
3387                        type Future = BoxFuture<
3388                            tonic::Response<Self::Response>,
3389                            tonic::Status,
3390                        >;
3391                        fn call(
3392                            &mut self,
3393                            request: tonic::Request<super::CreateSchemaRequest>,
3394                        ) -> Self::Future {
3395                            let inner = Arc::clone(&self.0);
3396                            let fut = async move {
3397                                <T as DdlService>::create_schema(&inner, request).await
3398                            };
3399                            Box::pin(fut)
3400                        }
3401                    }
3402                    let accept_compression_encodings = self.accept_compression_encodings;
3403                    let send_compression_encodings = self.send_compression_encodings;
3404                    let max_decoding_message_size = self.max_decoding_message_size;
3405                    let max_encoding_message_size = self.max_encoding_message_size;
3406                    let inner = self.inner.clone();
3407                    let fut = async move {
3408                        let method = CreateSchemaSvc(inner);
3409                        let codec = tonic_prost::ProstCodec::default();
3410                        let mut grpc = tonic::server::Grpc::new(codec)
3411                            .apply_compression_config(
3412                                accept_compression_encodings,
3413                                send_compression_encodings,
3414                            )
3415                            .apply_max_message_size_config(
3416                                max_decoding_message_size,
3417                                max_encoding_message_size,
3418                            );
3419                        let res = grpc.unary(method, req).await;
3420                        Ok(res)
3421                    };
3422                    Box::pin(fut)
3423                }
3424                "/ddl_service.DdlService/DropSchema" => {
3425                    #[allow(non_camel_case_types)]
3426                    struct DropSchemaSvc<T: DdlService>(pub Arc<T>);
3427                    impl<
3428                        T: DdlService,
3429                    > tonic::server::UnaryService<super::DropSchemaRequest>
3430                    for DropSchemaSvc<T> {
3431                        type Response = super::DropSchemaResponse;
3432                        type Future = BoxFuture<
3433                            tonic::Response<Self::Response>,
3434                            tonic::Status,
3435                        >;
3436                        fn call(
3437                            &mut self,
3438                            request: tonic::Request<super::DropSchemaRequest>,
3439                        ) -> Self::Future {
3440                            let inner = Arc::clone(&self.0);
3441                            let fut = async move {
3442                                <T as DdlService>::drop_schema(&inner, request).await
3443                            };
3444                            Box::pin(fut)
3445                        }
3446                    }
3447                    let accept_compression_encodings = self.accept_compression_encodings;
3448                    let send_compression_encodings = self.send_compression_encodings;
3449                    let max_decoding_message_size = self.max_decoding_message_size;
3450                    let max_encoding_message_size = self.max_encoding_message_size;
3451                    let inner = self.inner.clone();
3452                    let fut = async move {
3453                        let method = DropSchemaSvc(inner);
3454                        let codec = tonic_prost::ProstCodec::default();
3455                        let mut grpc = tonic::server::Grpc::new(codec)
3456                            .apply_compression_config(
3457                                accept_compression_encodings,
3458                                send_compression_encodings,
3459                            )
3460                            .apply_max_message_size_config(
3461                                max_decoding_message_size,
3462                                max_encoding_message_size,
3463                            );
3464                        let res = grpc.unary(method, req).await;
3465                        Ok(res)
3466                    };
3467                    Box::pin(fut)
3468                }
3469                "/ddl_service.DdlService/CreateSource" => {
3470                    #[allow(non_camel_case_types)]
3471                    struct CreateSourceSvc<T: DdlService>(pub Arc<T>);
3472                    impl<
3473                        T: DdlService,
3474                    > tonic::server::UnaryService<super::CreateSourceRequest>
3475                    for CreateSourceSvc<T> {
3476                        type Response = super::CreateSourceResponse;
3477                        type Future = BoxFuture<
3478                            tonic::Response<Self::Response>,
3479                            tonic::Status,
3480                        >;
3481                        fn call(
3482                            &mut self,
3483                            request: tonic::Request<super::CreateSourceRequest>,
3484                        ) -> Self::Future {
3485                            let inner = Arc::clone(&self.0);
3486                            let fut = async move {
3487                                <T as DdlService>::create_source(&inner, request).await
3488                            };
3489                            Box::pin(fut)
3490                        }
3491                    }
3492                    let accept_compression_encodings = self.accept_compression_encodings;
3493                    let send_compression_encodings = self.send_compression_encodings;
3494                    let max_decoding_message_size = self.max_decoding_message_size;
3495                    let max_encoding_message_size = self.max_encoding_message_size;
3496                    let inner = self.inner.clone();
3497                    let fut = async move {
3498                        let method = CreateSourceSvc(inner);
3499                        let codec = tonic_prost::ProstCodec::default();
3500                        let mut grpc = tonic::server::Grpc::new(codec)
3501                            .apply_compression_config(
3502                                accept_compression_encodings,
3503                                send_compression_encodings,
3504                            )
3505                            .apply_max_message_size_config(
3506                                max_decoding_message_size,
3507                                max_encoding_message_size,
3508                            );
3509                        let res = grpc.unary(method, req).await;
3510                        Ok(res)
3511                    };
3512                    Box::pin(fut)
3513                }
3514                "/ddl_service.DdlService/DropSource" => {
3515                    #[allow(non_camel_case_types)]
3516                    struct DropSourceSvc<T: DdlService>(pub Arc<T>);
3517                    impl<
3518                        T: DdlService,
3519                    > tonic::server::UnaryService<super::DropSourceRequest>
3520                    for DropSourceSvc<T> {
3521                        type Response = super::DropSourceResponse;
3522                        type Future = BoxFuture<
3523                            tonic::Response<Self::Response>,
3524                            tonic::Status,
3525                        >;
3526                        fn call(
3527                            &mut self,
3528                            request: tonic::Request<super::DropSourceRequest>,
3529                        ) -> Self::Future {
3530                            let inner = Arc::clone(&self.0);
3531                            let fut = async move {
3532                                <T as DdlService>::drop_source(&inner, request).await
3533                            };
3534                            Box::pin(fut)
3535                        }
3536                    }
3537                    let accept_compression_encodings = self.accept_compression_encodings;
3538                    let send_compression_encodings = self.send_compression_encodings;
3539                    let max_decoding_message_size = self.max_decoding_message_size;
3540                    let max_encoding_message_size = self.max_encoding_message_size;
3541                    let inner = self.inner.clone();
3542                    let fut = async move {
3543                        let method = DropSourceSvc(inner);
3544                        let codec = tonic_prost::ProstCodec::default();
3545                        let mut grpc = tonic::server::Grpc::new(codec)
3546                            .apply_compression_config(
3547                                accept_compression_encodings,
3548                                send_compression_encodings,
3549                            )
3550                            .apply_max_message_size_config(
3551                                max_decoding_message_size,
3552                                max_encoding_message_size,
3553                            );
3554                        let res = grpc.unary(method, req).await;
3555                        Ok(res)
3556                    };
3557                    Box::pin(fut)
3558                }
3559                "/ddl_service.DdlService/CreateSink" => {
3560                    #[allow(non_camel_case_types)]
3561                    struct CreateSinkSvc<T: DdlService>(pub Arc<T>);
3562                    impl<
3563                        T: DdlService,
3564                    > tonic::server::UnaryService<super::CreateSinkRequest>
3565                    for CreateSinkSvc<T> {
3566                        type Response = super::CreateSinkResponse;
3567                        type Future = BoxFuture<
3568                            tonic::Response<Self::Response>,
3569                            tonic::Status,
3570                        >;
3571                        fn call(
3572                            &mut self,
3573                            request: tonic::Request<super::CreateSinkRequest>,
3574                        ) -> Self::Future {
3575                            let inner = Arc::clone(&self.0);
3576                            let fut = async move {
3577                                <T as DdlService>::create_sink(&inner, request).await
3578                            };
3579                            Box::pin(fut)
3580                        }
3581                    }
3582                    let accept_compression_encodings = self.accept_compression_encodings;
3583                    let send_compression_encodings = self.send_compression_encodings;
3584                    let max_decoding_message_size = self.max_decoding_message_size;
3585                    let max_encoding_message_size = self.max_encoding_message_size;
3586                    let inner = self.inner.clone();
3587                    let fut = async move {
3588                        let method = CreateSinkSvc(inner);
3589                        let codec = tonic_prost::ProstCodec::default();
3590                        let mut grpc = tonic::server::Grpc::new(codec)
3591                            .apply_compression_config(
3592                                accept_compression_encodings,
3593                                send_compression_encodings,
3594                            )
3595                            .apply_max_message_size_config(
3596                                max_decoding_message_size,
3597                                max_encoding_message_size,
3598                            );
3599                        let res = grpc.unary(method, req).await;
3600                        Ok(res)
3601                    };
3602                    Box::pin(fut)
3603                }
3604                "/ddl_service.DdlService/CreateSubscription" => {
3605                    #[allow(non_camel_case_types)]
3606                    struct CreateSubscriptionSvc<T: DdlService>(pub Arc<T>);
3607                    impl<
3608                        T: DdlService,
3609                    > tonic::server::UnaryService<super::CreateSubscriptionRequest>
3610                    for CreateSubscriptionSvc<T> {
3611                        type Response = super::CreateSubscriptionResponse;
3612                        type Future = BoxFuture<
3613                            tonic::Response<Self::Response>,
3614                            tonic::Status,
3615                        >;
3616                        fn call(
3617                            &mut self,
3618                            request: tonic::Request<super::CreateSubscriptionRequest>,
3619                        ) -> Self::Future {
3620                            let inner = Arc::clone(&self.0);
3621                            let fut = async move {
3622                                <T as DdlService>::create_subscription(&inner, request)
3623                                    .await
3624                            };
3625                            Box::pin(fut)
3626                        }
3627                    }
3628                    let accept_compression_encodings = self.accept_compression_encodings;
3629                    let send_compression_encodings = self.send_compression_encodings;
3630                    let max_decoding_message_size = self.max_decoding_message_size;
3631                    let max_encoding_message_size = self.max_encoding_message_size;
3632                    let inner = self.inner.clone();
3633                    let fut = async move {
3634                        let method = CreateSubscriptionSvc(inner);
3635                        let codec = tonic_prost::ProstCodec::default();
3636                        let mut grpc = tonic::server::Grpc::new(codec)
3637                            .apply_compression_config(
3638                                accept_compression_encodings,
3639                                send_compression_encodings,
3640                            )
3641                            .apply_max_message_size_config(
3642                                max_decoding_message_size,
3643                                max_encoding_message_size,
3644                            );
3645                        let res = grpc.unary(method, req).await;
3646                        Ok(res)
3647                    };
3648                    Box::pin(fut)
3649                }
3650                "/ddl_service.DdlService/DropSink" => {
3651                    #[allow(non_camel_case_types)]
3652                    struct DropSinkSvc<T: DdlService>(pub Arc<T>);
3653                    impl<
3654                        T: DdlService,
3655                    > tonic::server::UnaryService<super::DropSinkRequest>
3656                    for DropSinkSvc<T> {
3657                        type Response = super::DropSinkResponse;
3658                        type Future = BoxFuture<
3659                            tonic::Response<Self::Response>,
3660                            tonic::Status,
3661                        >;
3662                        fn call(
3663                            &mut self,
3664                            request: tonic::Request<super::DropSinkRequest>,
3665                        ) -> Self::Future {
3666                            let inner = Arc::clone(&self.0);
3667                            let fut = async move {
3668                                <T as DdlService>::drop_sink(&inner, request).await
3669                            };
3670                            Box::pin(fut)
3671                        }
3672                    }
3673                    let accept_compression_encodings = self.accept_compression_encodings;
3674                    let send_compression_encodings = self.send_compression_encodings;
3675                    let max_decoding_message_size = self.max_decoding_message_size;
3676                    let max_encoding_message_size = self.max_encoding_message_size;
3677                    let inner = self.inner.clone();
3678                    let fut = async move {
3679                        let method = DropSinkSvc(inner);
3680                        let codec = tonic_prost::ProstCodec::default();
3681                        let mut grpc = tonic::server::Grpc::new(codec)
3682                            .apply_compression_config(
3683                                accept_compression_encodings,
3684                                send_compression_encodings,
3685                            )
3686                            .apply_max_message_size_config(
3687                                max_decoding_message_size,
3688                                max_encoding_message_size,
3689                            );
3690                        let res = grpc.unary(method, req).await;
3691                        Ok(res)
3692                    };
3693                    Box::pin(fut)
3694                }
3695                "/ddl_service.DdlService/DropSubscription" => {
3696                    #[allow(non_camel_case_types)]
3697                    struct DropSubscriptionSvc<T: DdlService>(pub Arc<T>);
3698                    impl<
3699                        T: DdlService,
3700                    > tonic::server::UnaryService<super::DropSubscriptionRequest>
3701                    for DropSubscriptionSvc<T> {
3702                        type Response = super::DropSubscriptionResponse;
3703                        type Future = BoxFuture<
3704                            tonic::Response<Self::Response>,
3705                            tonic::Status,
3706                        >;
3707                        fn call(
3708                            &mut self,
3709                            request: tonic::Request<super::DropSubscriptionRequest>,
3710                        ) -> Self::Future {
3711                            let inner = Arc::clone(&self.0);
3712                            let fut = async move {
3713                                <T as DdlService>::drop_subscription(&inner, request).await
3714                            };
3715                            Box::pin(fut)
3716                        }
3717                    }
3718                    let accept_compression_encodings = self.accept_compression_encodings;
3719                    let send_compression_encodings = self.send_compression_encodings;
3720                    let max_decoding_message_size = self.max_decoding_message_size;
3721                    let max_encoding_message_size = self.max_encoding_message_size;
3722                    let inner = self.inner.clone();
3723                    let fut = async move {
3724                        let method = DropSubscriptionSvc(inner);
3725                        let codec = tonic_prost::ProstCodec::default();
3726                        let mut grpc = tonic::server::Grpc::new(codec)
3727                            .apply_compression_config(
3728                                accept_compression_encodings,
3729                                send_compression_encodings,
3730                            )
3731                            .apply_max_message_size_config(
3732                                max_decoding_message_size,
3733                                max_encoding_message_size,
3734                            );
3735                        let res = grpc.unary(method, req).await;
3736                        Ok(res)
3737                    };
3738                    Box::pin(fut)
3739                }
3740                "/ddl_service.DdlService/CreateMaterializedView" => {
3741                    #[allow(non_camel_case_types)]
3742                    struct CreateMaterializedViewSvc<T: DdlService>(pub Arc<T>);
3743                    impl<
3744                        T: DdlService,
3745                    > tonic::server::UnaryService<super::CreateMaterializedViewRequest>
3746                    for CreateMaterializedViewSvc<T> {
3747                        type Response = super::CreateMaterializedViewResponse;
3748                        type Future = BoxFuture<
3749                            tonic::Response<Self::Response>,
3750                            tonic::Status,
3751                        >;
3752                        fn call(
3753                            &mut self,
3754                            request: tonic::Request<super::CreateMaterializedViewRequest>,
3755                        ) -> Self::Future {
3756                            let inner = Arc::clone(&self.0);
3757                            let fut = async move {
3758                                <T as DdlService>::create_materialized_view(&inner, request)
3759                                    .await
3760                            };
3761                            Box::pin(fut)
3762                        }
3763                    }
3764                    let accept_compression_encodings = self.accept_compression_encodings;
3765                    let send_compression_encodings = self.send_compression_encodings;
3766                    let max_decoding_message_size = self.max_decoding_message_size;
3767                    let max_encoding_message_size = self.max_encoding_message_size;
3768                    let inner = self.inner.clone();
3769                    let fut = async move {
3770                        let method = CreateMaterializedViewSvc(inner);
3771                        let codec = tonic_prost::ProstCodec::default();
3772                        let mut grpc = tonic::server::Grpc::new(codec)
3773                            .apply_compression_config(
3774                                accept_compression_encodings,
3775                                send_compression_encodings,
3776                            )
3777                            .apply_max_message_size_config(
3778                                max_decoding_message_size,
3779                                max_encoding_message_size,
3780                            );
3781                        let res = grpc.unary(method, req).await;
3782                        Ok(res)
3783                    };
3784                    Box::pin(fut)
3785                }
3786                "/ddl_service.DdlService/DropMaterializedView" => {
3787                    #[allow(non_camel_case_types)]
3788                    struct DropMaterializedViewSvc<T: DdlService>(pub Arc<T>);
3789                    impl<
3790                        T: DdlService,
3791                    > tonic::server::UnaryService<super::DropMaterializedViewRequest>
3792                    for DropMaterializedViewSvc<T> {
3793                        type Response = super::DropMaterializedViewResponse;
3794                        type Future = BoxFuture<
3795                            tonic::Response<Self::Response>,
3796                            tonic::Status,
3797                        >;
3798                        fn call(
3799                            &mut self,
3800                            request: tonic::Request<super::DropMaterializedViewRequest>,
3801                        ) -> Self::Future {
3802                            let inner = Arc::clone(&self.0);
3803                            let fut = async move {
3804                                <T as DdlService>::drop_materialized_view(&inner, request)
3805                                    .await
3806                            };
3807                            Box::pin(fut)
3808                        }
3809                    }
3810                    let accept_compression_encodings = self.accept_compression_encodings;
3811                    let send_compression_encodings = self.send_compression_encodings;
3812                    let max_decoding_message_size = self.max_decoding_message_size;
3813                    let max_encoding_message_size = self.max_encoding_message_size;
3814                    let inner = self.inner.clone();
3815                    let fut = async move {
3816                        let method = DropMaterializedViewSvc(inner);
3817                        let codec = tonic_prost::ProstCodec::default();
3818                        let mut grpc = tonic::server::Grpc::new(codec)
3819                            .apply_compression_config(
3820                                accept_compression_encodings,
3821                                send_compression_encodings,
3822                            )
3823                            .apply_max_message_size_config(
3824                                max_decoding_message_size,
3825                                max_encoding_message_size,
3826                            );
3827                        let res = grpc.unary(method, req).await;
3828                        Ok(res)
3829                    };
3830                    Box::pin(fut)
3831                }
3832                "/ddl_service.DdlService/CreateTable" => {
3833                    #[allow(non_camel_case_types)]
3834                    struct CreateTableSvc<T: DdlService>(pub Arc<T>);
3835                    impl<
3836                        T: DdlService,
3837                    > tonic::server::UnaryService<super::CreateTableRequest>
3838                    for CreateTableSvc<T> {
3839                        type Response = super::CreateTableResponse;
3840                        type Future = BoxFuture<
3841                            tonic::Response<Self::Response>,
3842                            tonic::Status,
3843                        >;
3844                        fn call(
3845                            &mut self,
3846                            request: tonic::Request<super::CreateTableRequest>,
3847                        ) -> Self::Future {
3848                            let inner = Arc::clone(&self.0);
3849                            let fut = async move {
3850                                <T as DdlService>::create_table(&inner, request).await
3851                            };
3852                            Box::pin(fut)
3853                        }
3854                    }
3855                    let accept_compression_encodings = self.accept_compression_encodings;
3856                    let send_compression_encodings = self.send_compression_encodings;
3857                    let max_decoding_message_size = self.max_decoding_message_size;
3858                    let max_encoding_message_size = self.max_encoding_message_size;
3859                    let inner = self.inner.clone();
3860                    let fut = async move {
3861                        let method = CreateTableSvc(inner);
3862                        let codec = tonic_prost::ProstCodec::default();
3863                        let mut grpc = tonic::server::Grpc::new(codec)
3864                            .apply_compression_config(
3865                                accept_compression_encodings,
3866                                send_compression_encodings,
3867                            )
3868                            .apply_max_message_size_config(
3869                                max_decoding_message_size,
3870                                max_encoding_message_size,
3871                            );
3872                        let res = grpc.unary(method, req).await;
3873                        Ok(res)
3874                    };
3875                    Box::pin(fut)
3876                }
3877                "/ddl_service.DdlService/CreateIcebergTable" => {
3878                    #[allow(non_camel_case_types)]
3879                    struct CreateIcebergTableSvc<T: DdlService>(pub Arc<T>);
3880                    impl<
3881                        T: DdlService,
3882                    > tonic::server::UnaryService<super::CreateIcebergTableRequest>
3883                    for CreateIcebergTableSvc<T> {
3884                        type Response = super::CreateIcebergTableResponse;
3885                        type Future = BoxFuture<
3886                            tonic::Response<Self::Response>,
3887                            tonic::Status,
3888                        >;
3889                        fn call(
3890                            &mut self,
3891                            request: tonic::Request<super::CreateIcebergTableRequest>,
3892                        ) -> Self::Future {
3893                            let inner = Arc::clone(&self.0);
3894                            let fut = async move {
3895                                <T as DdlService>::create_iceberg_table(&inner, request)
3896                                    .await
3897                            };
3898                            Box::pin(fut)
3899                        }
3900                    }
3901                    let accept_compression_encodings = self.accept_compression_encodings;
3902                    let send_compression_encodings = self.send_compression_encodings;
3903                    let max_decoding_message_size = self.max_decoding_message_size;
3904                    let max_encoding_message_size = self.max_encoding_message_size;
3905                    let inner = self.inner.clone();
3906                    let fut = async move {
3907                        let method = CreateIcebergTableSvc(inner);
3908                        let codec = tonic_prost::ProstCodec::default();
3909                        let mut grpc = tonic::server::Grpc::new(codec)
3910                            .apply_compression_config(
3911                                accept_compression_encodings,
3912                                send_compression_encodings,
3913                            )
3914                            .apply_max_message_size_config(
3915                                max_decoding_message_size,
3916                                max_encoding_message_size,
3917                            );
3918                        let res = grpc.unary(method, req).await;
3919                        Ok(res)
3920                    };
3921                    Box::pin(fut)
3922                }
3923                "/ddl_service.DdlService/CreateSecret" => {
3924                    #[allow(non_camel_case_types)]
3925                    struct CreateSecretSvc<T: DdlService>(pub Arc<T>);
3926                    impl<
3927                        T: DdlService,
3928                    > tonic::server::UnaryService<super::CreateSecretRequest>
3929                    for CreateSecretSvc<T> {
3930                        type Response = super::CreateSecretResponse;
3931                        type Future = BoxFuture<
3932                            tonic::Response<Self::Response>,
3933                            tonic::Status,
3934                        >;
3935                        fn call(
3936                            &mut self,
3937                            request: tonic::Request<super::CreateSecretRequest>,
3938                        ) -> Self::Future {
3939                            let inner = Arc::clone(&self.0);
3940                            let fut = async move {
3941                                <T as DdlService>::create_secret(&inner, request).await
3942                            };
3943                            Box::pin(fut)
3944                        }
3945                    }
3946                    let accept_compression_encodings = self.accept_compression_encodings;
3947                    let send_compression_encodings = self.send_compression_encodings;
3948                    let max_decoding_message_size = self.max_decoding_message_size;
3949                    let max_encoding_message_size = self.max_encoding_message_size;
3950                    let inner = self.inner.clone();
3951                    let fut = async move {
3952                        let method = CreateSecretSvc(inner);
3953                        let codec = tonic_prost::ProstCodec::default();
3954                        let mut grpc = tonic::server::Grpc::new(codec)
3955                            .apply_compression_config(
3956                                accept_compression_encodings,
3957                                send_compression_encodings,
3958                            )
3959                            .apply_max_message_size_config(
3960                                max_decoding_message_size,
3961                                max_encoding_message_size,
3962                            );
3963                        let res = grpc.unary(method, req).await;
3964                        Ok(res)
3965                    };
3966                    Box::pin(fut)
3967                }
3968                "/ddl_service.DdlService/DropSecret" => {
3969                    #[allow(non_camel_case_types)]
3970                    struct DropSecretSvc<T: DdlService>(pub Arc<T>);
3971                    impl<
3972                        T: DdlService,
3973                    > tonic::server::UnaryService<super::DropSecretRequest>
3974                    for DropSecretSvc<T> {
3975                        type Response = super::DropSecretResponse;
3976                        type Future = BoxFuture<
3977                            tonic::Response<Self::Response>,
3978                            tonic::Status,
3979                        >;
3980                        fn call(
3981                            &mut self,
3982                            request: tonic::Request<super::DropSecretRequest>,
3983                        ) -> Self::Future {
3984                            let inner = Arc::clone(&self.0);
3985                            let fut = async move {
3986                                <T as DdlService>::drop_secret(&inner, request).await
3987                            };
3988                            Box::pin(fut)
3989                        }
3990                    }
3991                    let accept_compression_encodings = self.accept_compression_encodings;
3992                    let send_compression_encodings = self.send_compression_encodings;
3993                    let max_decoding_message_size = self.max_decoding_message_size;
3994                    let max_encoding_message_size = self.max_encoding_message_size;
3995                    let inner = self.inner.clone();
3996                    let fut = async move {
3997                        let method = DropSecretSvc(inner);
3998                        let codec = tonic_prost::ProstCodec::default();
3999                        let mut grpc = tonic::server::Grpc::new(codec)
4000                            .apply_compression_config(
4001                                accept_compression_encodings,
4002                                send_compression_encodings,
4003                            )
4004                            .apply_max_message_size_config(
4005                                max_decoding_message_size,
4006                                max_encoding_message_size,
4007                            );
4008                        let res = grpc.unary(method, req).await;
4009                        Ok(res)
4010                    };
4011                    Box::pin(fut)
4012                }
4013                "/ddl_service.DdlService/AlterSecret" => {
4014                    #[allow(non_camel_case_types)]
4015                    struct AlterSecretSvc<T: DdlService>(pub Arc<T>);
4016                    impl<
4017                        T: DdlService,
4018                    > tonic::server::UnaryService<super::AlterSecretRequest>
4019                    for AlterSecretSvc<T> {
4020                        type Response = super::AlterSecretResponse;
4021                        type Future = BoxFuture<
4022                            tonic::Response<Self::Response>,
4023                            tonic::Status,
4024                        >;
4025                        fn call(
4026                            &mut self,
4027                            request: tonic::Request<super::AlterSecretRequest>,
4028                        ) -> Self::Future {
4029                            let inner = Arc::clone(&self.0);
4030                            let fut = async move {
4031                                <T as DdlService>::alter_secret(&inner, request).await
4032                            };
4033                            Box::pin(fut)
4034                        }
4035                    }
4036                    let accept_compression_encodings = self.accept_compression_encodings;
4037                    let send_compression_encodings = self.send_compression_encodings;
4038                    let max_decoding_message_size = self.max_decoding_message_size;
4039                    let max_encoding_message_size = self.max_encoding_message_size;
4040                    let inner = self.inner.clone();
4041                    let fut = async move {
4042                        let method = AlterSecretSvc(inner);
4043                        let codec = tonic_prost::ProstCodec::default();
4044                        let mut grpc = tonic::server::Grpc::new(codec)
4045                            .apply_compression_config(
4046                                accept_compression_encodings,
4047                                send_compression_encodings,
4048                            )
4049                            .apply_max_message_size_config(
4050                                max_decoding_message_size,
4051                                max_encoding_message_size,
4052                            );
4053                        let res = grpc.unary(method, req).await;
4054                        Ok(res)
4055                    };
4056                    Box::pin(fut)
4057                }
4058                "/ddl_service.DdlService/AlterName" => {
4059                    #[allow(non_camel_case_types)]
4060                    struct AlterNameSvc<T: DdlService>(pub Arc<T>);
4061                    impl<
4062                        T: DdlService,
4063                    > tonic::server::UnaryService<super::AlterNameRequest>
4064                    for AlterNameSvc<T> {
4065                        type Response = super::AlterNameResponse;
4066                        type Future = BoxFuture<
4067                            tonic::Response<Self::Response>,
4068                            tonic::Status,
4069                        >;
4070                        fn call(
4071                            &mut self,
4072                            request: tonic::Request<super::AlterNameRequest>,
4073                        ) -> Self::Future {
4074                            let inner = Arc::clone(&self.0);
4075                            let fut = async move {
4076                                <T as DdlService>::alter_name(&inner, request).await
4077                            };
4078                            Box::pin(fut)
4079                        }
4080                    }
4081                    let accept_compression_encodings = self.accept_compression_encodings;
4082                    let send_compression_encodings = self.send_compression_encodings;
4083                    let max_decoding_message_size = self.max_decoding_message_size;
4084                    let max_encoding_message_size = self.max_encoding_message_size;
4085                    let inner = self.inner.clone();
4086                    let fut = async move {
4087                        let method = AlterNameSvc(inner);
4088                        let codec = tonic_prost::ProstCodec::default();
4089                        let mut grpc = tonic::server::Grpc::new(codec)
4090                            .apply_compression_config(
4091                                accept_compression_encodings,
4092                                send_compression_encodings,
4093                            )
4094                            .apply_max_message_size_config(
4095                                max_decoding_message_size,
4096                                max_encoding_message_size,
4097                            );
4098                        let res = grpc.unary(method, req).await;
4099                        Ok(res)
4100                    };
4101                    Box::pin(fut)
4102                }
4103                "/ddl_service.DdlService/AlterSource" => {
4104                    #[allow(non_camel_case_types)]
4105                    struct AlterSourceSvc<T: DdlService>(pub Arc<T>);
4106                    impl<
4107                        T: DdlService,
4108                    > tonic::server::UnaryService<super::AlterSourceRequest>
4109                    for AlterSourceSvc<T> {
4110                        type Response = super::AlterSourceResponse;
4111                        type Future = BoxFuture<
4112                            tonic::Response<Self::Response>,
4113                            tonic::Status,
4114                        >;
4115                        fn call(
4116                            &mut self,
4117                            request: tonic::Request<super::AlterSourceRequest>,
4118                        ) -> Self::Future {
4119                            let inner = Arc::clone(&self.0);
4120                            let fut = async move {
4121                                <T as DdlService>::alter_source(&inner, request).await
4122                            };
4123                            Box::pin(fut)
4124                        }
4125                    }
4126                    let accept_compression_encodings = self.accept_compression_encodings;
4127                    let send_compression_encodings = self.send_compression_encodings;
4128                    let max_decoding_message_size = self.max_decoding_message_size;
4129                    let max_encoding_message_size = self.max_encoding_message_size;
4130                    let inner = self.inner.clone();
4131                    let fut = async move {
4132                        let method = AlterSourceSvc(inner);
4133                        let codec = tonic_prost::ProstCodec::default();
4134                        let mut grpc = tonic::server::Grpc::new(codec)
4135                            .apply_compression_config(
4136                                accept_compression_encodings,
4137                                send_compression_encodings,
4138                            )
4139                            .apply_max_message_size_config(
4140                                max_decoding_message_size,
4141                                max_encoding_message_size,
4142                            );
4143                        let res = grpc.unary(method, req).await;
4144                        Ok(res)
4145                    };
4146                    Box::pin(fut)
4147                }
4148                "/ddl_service.DdlService/ResetSource" => {
4149                    #[allow(non_camel_case_types)]
4150                    struct ResetSourceSvc<T: DdlService>(pub Arc<T>);
4151                    impl<
4152                        T: DdlService,
4153                    > tonic::server::UnaryService<super::ResetSourceRequest>
4154                    for ResetSourceSvc<T> {
4155                        type Response = super::ResetSourceResponse;
4156                        type Future = BoxFuture<
4157                            tonic::Response<Self::Response>,
4158                            tonic::Status,
4159                        >;
4160                        fn call(
4161                            &mut self,
4162                            request: tonic::Request<super::ResetSourceRequest>,
4163                        ) -> Self::Future {
4164                            let inner = Arc::clone(&self.0);
4165                            let fut = async move {
4166                                <T as DdlService>::reset_source(&inner, request).await
4167                            };
4168                            Box::pin(fut)
4169                        }
4170                    }
4171                    let accept_compression_encodings = self.accept_compression_encodings;
4172                    let send_compression_encodings = self.send_compression_encodings;
4173                    let max_decoding_message_size = self.max_decoding_message_size;
4174                    let max_encoding_message_size = self.max_encoding_message_size;
4175                    let inner = self.inner.clone();
4176                    let fut = async move {
4177                        let method = ResetSourceSvc(inner);
4178                        let codec = tonic_prost::ProstCodec::default();
4179                        let mut grpc = tonic::server::Grpc::new(codec)
4180                            .apply_compression_config(
4181                                accept_compression_encodings,
4182                                send_compression_encodings,
4183                            )
4184                            .apply_max_message_size_config(
4185                                max_decoding_message_size,
4186                                max_encoding_message_size,
4187                            );
4188                        let res = grpc.unary(method, req).await;
4189                        Ok(res)
4190                    };
4191                    Box::pin(fut)
4192                }
4193                "/ddl_service.DdlService/AlterOwner" => {
4194                    #[allow(non_camel_case_types)]
4195                    struct AlterOwnerSvc<T: DdlService>(pub Arc<T>);
4196                    impl<
4197                        T: DdlService,
4198                    > tonic::server::UnaryService<super::AlterOwnerRequest>
4199                    for AlterOwnerSvc<T> {
4200                        type Response = super::AlterOwnerResponse;
4201                        type Future = BoxFuture<
4202                            tonic::Response<Self::Response>,
4203                            tonic::Status,
4204                        >;
4205                        fn call(
4206                            &mut self,
4207                            request: tonic::Request<super::AlterOwnerRequest>,
4208                        ) -> Self::Future {
4209                            let inner = Arc::clone(&self.0);
4210                            let fut = async move {
4211                                <T as DdlService>::alter_owner(&inner, request).await
4212                            };
4213                            Box::pin(fut)
4214                        }
4215                    }
4216                    let accept_compression_encodings = self.accept_compression_encodings;
4217                    let send_compression_encodings = self.send_compression_encodings;
4218                    let max_decoding_message_size = self.max_decoding_message_size;
4219                    let max_encoding_message_size = self.max_encoding_message_size;
4220                    let inner = self.inner.clone();
4221                    let fut = async move {
4222                        let method = AlterOwnerSvc(inner);
4223                        let codec = tonic_prost::ProstCodec::default();
4224                        let mut grpc = tonic::server::Grpc::new(codec)
4225                            .apply_compression_config(
4226                                accept_compression_encodings,
4227                                send_compression_encodings,
4228                            )
4229                            .apply_max_message_size_config(
4230                                max_decoding_message_size,
4231                                max_encoding_message_size,
4232                            );
4233                        let res = grpc.unary(method, req).await;
4234                        Ok(res)
4235                    };
4236                    Box::pin(fut)
4237                }
4238                "/ddl_service.DdlService/AlterSubscriptionRetention" => {
4239                    #[allow(non_camel_case_types)]
4240                    struct AlterSubscriptionRetentionSvc<T: DdlService>(pub Arc<T>);
4241                    impl<
4242                        T: DdlService,
4243                    > tonic::server::UnaryService<
4244                        super::AlterSubscriptionRetentionRequest,
4245                    > for AlterSubscriptionRetentionSvc<T> {
4246                        type Response = super::AlterSubscriptionRetentionResponse;
4247                        type Future = BoxFuture<
4248                            tonic::Response<Self::Response>,
4249                            tonic::Status,
4250                        >;
4251                        fn call(
4252                            &mut self,
4253                            request: tonic::Request<
4254                                super::AlterSubscriptionRetentionRequest,
4255                            >,
4256                        ) -> Self::Future {
4257                            let inner = Arc::clone(&self.0);
4258                            let fut = async move {
4259                                <T as DdlService>::alter_subscription_retention(
4260                                        &inner,
4261                                        request,
4262                                    )
4263                                    .await
4264                            };
4265                            Box::pin(fut)
4266                        }
4267                    }
4268                    let accept_compression_encodings = self.accept_compression_encodings;
4269                    let send_compression_encodings = self.send_compression_encodings;
4270                    let max_decoding_message_size = self.max_decoding_message_size;
4271                    let max_encoding_message_size = self.max_encoding_message_size;
4272                    let inner = self.inner.clone();
4273                    let fut = async move {
4274                        let method = AlterSubscriptionRetentionSvc(inner);
4275                        let codec = tonic_prost::ProstCodec::default();
4276                        let mut grpc = tonic::server::Grpc::new(codec)
4277                            .apply_compression_config(
4278                                accept_compression_encodings,
4279                                send_compression_encodings,
4280                            )
4281                            .apply_max_message_size_config(
4282                                max_decoding_message_size,
4283                                max_encoding_message_size,
4284                            );
4285                        let res = grpc.unary(method, req).await;
4286                        Ok(res)
4287                    };
4288                    Box::pin(fut)
4289                }
4290                "/ddl_service.DdlService/AlterSetSchema" => {
4291                    #[allow(non_camel_case_types)]
4292                    struct AlterSetSchemaSvc<T: DdlService>(pub Arc<T>);
4293                    impl<
4294                        T: DdlService,
4295                    > tonic::server::UnaryService<super::AlterSetSchemaRequest>
4296                    for AlterSetSchemaSvc<T> {
4297                        type Response = super::AlterSetSchemaResponse;
4298                        type Future = BoxFuture<
4299                            tonic::Response<Self::Response>,
4300                            tonic::Status,
4301                        >;
4302                        fn call(
4303                            &mut self,
4304                            request: tonic::Request<super::AlterSetSchemaRequest>,
4305                        ) -> Self::Future {
4306                            let inner = Arc::clone(&self.0);
4307                            let fut = async move {
4308                                <T as DdlService>::alter_set_schema(&inner, request).await
4309                            };
4310                            Box::pin(fut)
4311                        }
4312                    }
4313                    let accept_compression_encodings = self.accept_compression_encodings;
4314                    let send_compression_encodings = self.send_compression_encodings;
4315                    let max_decoding_message_size = self.max_decoding_message_size;
4316                    let max_encoding_message_size = self.max_encoding_message_size;
4317                    let inner = self.inner.clone();
4318                    let fut = async move {
4319                        let method = AlterSetSchemaSvc(inner);
4320                        let codec = tonic_prost::ProstCodec::default();
4321                        let mut grpc = tonic::server::Grpc::new(codec)
4322                            .apply_compression_config(
4323                                accept_compression_encodings,
4324                                send_compression_encodings,
4325                            )
4326                            .apply_max_message_size_config(
4327                                max_decoding_message_size,
4328                                max_encoding_message_size,
4329                            );
4330                        let res = grpc.unary(method, req).await;
4331                        Ok(res)
4332                    };
4333                    Box::pin(fut)
4334                }
4335                "/ddl_service.DdlService/AlterParallelism" => {
4336                    #[allow(non_camel_case_types)]
4337                    struct AlterParallelismSvc<T: DdlService>(pub Arc<T>);
4338                    impl<
4339                        T: DdlService,
4340                    > tonic::server::UnaryService<super::AlterParallelismRequest>
4341                    for AlterParallelismSvc<T> {
4342                        type Response = super::AlterParallelismResponse;
4343                        type Future = BoxFuture<
4344                            tonic::Response<Self::Response>,
4345                            tonic::Status,
4346                        >;
4347                        fn call(
4348                            &mut self,
4349                            request: tonic::Request<super::AlterParallelismRequest>,
4350                        ) -> Self::Future {
4351                            let inner = Arc::clone(&self.0);
4352                            let fut = async move {
4353                                <T as DdlService>::alter_parallelism(&inner, request).await
4354                            };
4355                            Box::pin(fut)
4356                        }
4357                    }
4358                    let accept_compression_encodings = self.accept_compression_encodings;
4359                    let send_compression_encodings = self.send_compression_encodings;
4360                    let max_decoding_message_size = self.max_decoding_message_size;
4361                    let max_encoding_message_size = self.max_encoding_message_size;
4362                    let inner = self.inner.clone();
4363                    let fut = async move {
4364                        let method = AlterParallelismSvc(inner);
4365                        let codec = tonic_prost::ProstCodec::default();
4366                        let mut grpc = tonic::server::Grpc::new(codec)
4367                            .apply_compression_config(
4368                                accept_compression_encodings,
4369                                send_compression_encodings,
4370                            )
4371                            .apply_max_message_size_config(
4372                                max_decoding_message_size,
4373                                max_encoding_message_size,
4374                            );
4375                        let res = grpc.unary(method, req).await;
4376                        Ok(res)
4377                    };
4378                    Box::pin(fut)
4379                }
4380                "/ddl_service.DdlService/AlterBackfillParallelism" => {
4381                    #[allow(non_camel_case_types)]
4382                    struct AlterBackfillParallelismSvc<T: DdlService>(pub Arc<T>);
4383                    impl<
4384                        T: DdlService,
4385                    > tonic::server::UnaryService<super::AlterBackfillParallelismRequest>
4386                    for AlterBackfillParallelismSvc<T> {
4387                        type Response = super::AlterBackfillParallelismResponse;
4388                        type Future = BoxFuture<
4389                            tonic::Response<Self::Response>,
4390                            tonic::Status,
4391                        >;
4392                        fn call(
4393                            &mut self,
4394                            request: tonic::Request<
4395                                super::AlterBackfillParallelismRequest,
4396                            >,
4397                        ) -> Self::Future {
4398                            let inner = Arc::clone(&self.0);
4399                            let fut = async move {
4400                                <T as DdlService>::alter_backfill_parallelism(
4401                                        &inner,
4402                                        request,
4403                                    )
4404                                    .await
4405                            };
4406                            Box::pin(fut)
4407                        }
4408                    }
4409                    let accept_compression_encodings = self.accept_compression_encodings;
4410                    let send_compression_encodings = self.send_compression_encodings;
4411                    let max_decoding_message_size = self.max_decoding_message_size;
4412                    let max_encoding_message_size = self.max_encoding_message_size;
4413                    let inner = self.inner.clone();
4414                    let fut = async move {
4415                        let method = AlterBackfillParallelismSvc(inner);
4416                        let codec = tonic_prost::ProstCodec::default();
4417                        let mut grpc = tonic::server::Grpc::new(codec)
4418                            .apply_compression_config(
4419                                accept_compression_encodings,
4420                                send_compression_encodings,
4421                            )
4422                            .apply_max_message_size_config(
4423                                max_decoding_message_size,
4424                                max_encoding_message_size,
4425                            );
4426                        let res = grpc.unary(method, req).await;
4427                        Ok(res)
4428                    };
4429                    Box::pin(fut)
4430                }
4431                "/ddl_service.DdlService/AlterFragmentParallelism" => {
4432                    #[allow(non_camel_case_types)]
4433                    struct AlterFragmentParallelismSvc<T: DdlService>(pub Arc<T>);
4434                    impl<
4435                        T: DdlService,
4436                    > tonic::server::UnaryService<super::AlterFragmentParallelismRequest>
4437                    for AlterFragmentParallelismSvc<T> {
4438                        type Response = super::AlterFragmentParallelismResponse;
4439                        type Future = BoxFuture<
4440                            tonic::Response<Self::Response>,
4441                            tonic::Status,
4442                        >;
4443                        fn call(
4444                            &mut self,
4445                            request: tonic::Request<
4446                                super::AlterFragmentParallelismRequest,
4447                            >,
4448                        ) -> Self::Future {
4449                            let inner = Arc::clone(&self.0);
4450                            let fut = async move {
4451                                <T as DdlService>::alter_fragment_parallelism(
4452                                        &inner,
4453                                        request,
4454                                    )
4455                                    .await
4456                            };
4457                            Box::pin(fut)
4458                        }
4459                    }
4460                    let accept_compression_encodings = self.accept_compression_encodings;
4461                    let send_compression_encodings = self.send_compression_encodings;
4462                    let max_decoding_message_size = self.max_decoding_message_size;
4463                    let max_encoding_message_size = self.max_encoding_message_size;
4464                    let inner = self.inner.clone();
4465                    let fut = async move {
4466                        let method = AlterFragmentParallelismSvc(inner);
4467                        let codec = tonic_prost::ProstCodec::default();
4468                        let mut grpc = tonic::server::Grpc::new(codec)
4469                            .apply_compression_config(
4470                                accept_compression_encodings,
4471                                send_compression_encodings,
4472                            )
4473                            .apply_max_message_size_config(
4474                                max_decoding_message_size,
4475                                max_encoding_message_size,
4476                            );
4477                        let res = grpc.unary(method, req).await;
4478                        Ok(res)
4479                    };
4480                    Box::pin(fut)
4481                }
4482                "/ddl_service.DdlService/AlterResourceGroup" => {
4483                    #[allow(non_camel_case_types)]
4484                    struct AlterResourceGroupSvc<T: DdlService>(pub Arc<T>);
4485                    impl<
4486                        T: DdlService,
4487                    > tonic::server::UnaryService<super::AlterResourceGroupRequest>
4488                    for AlterResourceGroupSvc<T> {
4489                        type Response = super::AlterResourceGroupResponse;
4490                        type Future = BoxFuture<
4491                            tonic::Response<Self::Response>,
4492                            tonic::Status,
4493                        >;
4494                        fn call(
4495                            &mut self,
4496                            request: tonic::Request<super::AlterResourceGroupRequest>,
4497                        ) -> Self::Future {
4498                            let inner = Arc::clone(&self.0);
4499                            let fut = async move {
4500                                <T as DdlService>::alter_resource_group(&inner, request)
4501                                    .await
4502                            };
4503                            Box::pin(fut)
4504                        }
4505                    }
4506                    let accept_compression_encodings = self.accept_compression_encodings;
4507                    let send_compression_encodings = self.send_compression_encodings;
4508                    let max_decoding_message_size = self.max_decoding_message_size;
4509                    let max_encoding_message_size = self.max_encoding_message_size;
4510                    let inner = self.inner.clone();
4511                    let fut = async move {
4512                        let method = AlterResourceGroupSvc(inner);
4513                        let codec = tonic_prost::ProstCodec::default();
4514                        let mut grpc = tonic::server::Grpc::new(codec)
4515                            .apply_compression_config(
4516                                accept_compression_encodings,
4517                                send_compression_encodings,
4518                            )
4519                            .apply_max_message_size_config(
4520                                max_decoding_message_size,
4521                                max_encoding_message_size,
4522                            );
4523                        let res = grpc.unary(method, req).await;
4524                        Ok(res)
4525                    };
4526                    Box::pin(fut)
4527                }
4528                "/ddl_service.DdlService/AlterDatabaseResourceGroup" => {
4529                    #[allow(non_camel_case_types)]
4530                    struct AlterDatabaseResourceGroupSvc<T: DdlService>(pub Arc<T>);
4531                    impl<
4532                        T: DdlService,
4533                    > tonic::server::UnaryService<
4534                        super::AlterDatabaseResourceGroupRequest,
4535                    > for AlterDatabaseResourceGroupSvc<T> {
4536                        type Response = super::AlterDatabaseResourceGroupResponse;
4537                        type Future = BoxFuture<
4538                            tonic::Response<Self::Response>,
4539                            tonic::Status,
4540                        >;
4541                        fn call(
4542                            &mut self,
4543                            request: tonic::Request<
4544                                super::AlterDatabaseResourceGroupRequest,
4545                            >,
4546                        ) -> Self::Future {
4547                            let inner = Arc::clone(&self.0);
4548                            let fut = async move {
4549                                <T as DdlService>::alter_database_resource_group(
4550                                        &inner,
4551                                        request,
4552                                    )
4553                                    .await
4554                            };
4555                            Box::pin(fut)
4556                        }
4557                    }
4558                    let accept_compression_encodings = self.accept_compression_encodings;
4559                    let send_compression_encodings = self.send_compression_encodings;
4560                    let max_decoding_message_size = self.max_decoding_message_size;
4561                    let max_encoding_message_size = self.max_encoding_message_size;
4562                    let inner = self.inner.clone();
4563                    let fut = async move {
4564                        let method = AlterDatabaseResourceGroupSvc(inner);
4565                        let codec = tonic_prost::ProstCodec::default();
4566                        let mut grpc = tonic::server::Grpc::new(codec)
4567                            .apply_compression_config(
4568                                accept_compression_encodings,
4569                                send_compression_encodings,
4570                            )
4571                            .apply_max_message_size_config(
4572                                max_decoding_message_size,
4573                                max_encoding_message_size,
4574                            );
4575                        let res = grpc.unary(method, req).await;
4576                        Ok(res)
4577                    };
4578                    Box::pin(fut)
4579                }
4580                "/ddl_service.DdlService/DropTable" => {
4581                    #[allow(non_camel_case_types)]
4582                    struct DropTableSvc<T: DdlService>(pub Arc<T>);
4583                    impl<
4584                        T: DdlService,
4585                    > tonic::server::UnaryService<super::DropTableRequest>
4586                    for DropTableSvc<T> {
4587                        type Response = super::DropTableResponse;
4588                        type Future = BoxFuture<
4589                            tonic::Response<Self::Response>,
4590                            tonic::Status,
4591                        >;
4592                        fn call(
4593                            &mut self,
4594                            request: tonic::Request<super::DropTableRequest>,
4595                        ) -> Self::Future {
4596                            let inner = Arc::clone(&self.0);
4597                            let fut = async move {
4598                                <T as DdlService>::drop_table(&inner, request).await
4599                            };
4600                            Box::pin(fut)
4601                        }
4602                    }
4603                    let accept_compression_encodings = self.accept_compression_encodings;
4604                    let send_compression_encodings = self.send_compression_encodings;
4605                    let max_decoding_message_size = self.max_decoding_message_size;
4606                    let max_encoding_message_size = self.max_encoding_message_size;
4607                    let inner = self.inner.clone();
4608                    let fut = async move {
4609                        let method = DropTableSvc(inner);
4610                        let codec = tonic_prost::ProstCodec::default();
4611                        let mut grpc = tonic::server::Grpc::new(codec)
4612                            .apply_compression_config(
4613                                accept_compression_encodings,
4614                                send_compression_encodings,
4615                            )
4616                            .apply_max_message_size_config(
4617                                max_decoding_message_size,
4618                                max_encoding_message_size,
4619                            );
4620                        let res = grpc.unary(method, req).await;
4621                        Ok(res)
4622                    };
4623                    Box::pin(fut)
4624                }
4625                "/ddl_service.DdlService/RisectlListStateTables" => {
4626                    #[allow(non_camel_case_types)]
4627                    struct RisectlListStateTablesSvc<T: DdlService>(pub Arc<T>);
4628                    impl<
4629                        T: DdlService,
4630                    > tonic::server::UnaryService<super::RisectlListStateTablesRequest>
4631                    for RisectlListStateTablesSvc<T> {
4632                        type Response = super::RisectlListStateTablesResponse;
4633                        type Future = BoxFuture<
4634                            tonic::Response<Self::Response>,
4635                            tonic::Status,
4636                        >;
4637                        fn call(
4638                            &mut self,
4639                            request: tonic::Request<super::RisectlListStateTablesRequest>,
4640                        ) -> Self::Future {
4641                            let inner = Arc::clone(&self.0);
4642                            let fut = async move {
4643                                <T as DdlService>::risectl_list_state_tables(
4644                                        &inner,
4645                                        request,
4646                                    )
4647                                    .await
4648                            };
4649                            Box::pin(fut)
4650                        }
4651                    }
4652                    let accept_compression_encodings = self.accept_compression_encodings;
4653                    let send_compression_encodings = self.send_compression_encodings;
4654                    let max_decoding_message_size = self.max_decoding_message_size;
4655                    let max_encoding_message_size = self.max_encoding_message_size;
4656                    let inner = self.inner.clone();
4657                    let fut = async move {
4658                        let method = RisectlListStateTablesSvc(inner);
4659                        let codec = tonic_prost::ProstCodec::default();
4660                        let mut grpc = tonic::server::Grpc::new(codec)
4661                            .apply_compression_config(
4662                                accept_compression_encodings,
4663                                send_compression_encodings,
4664                            )
4665                            .apply_max_message_size_config(
4666                                max_decoding_message_size,
4667                                max_encoding_message_size,
4668                            );
4669                        let res = grpc.unary(method, req).await;
4670                        Ok(res)
4671                    };
4672                    Box::pin(fut)
4673                }
4674                "/ddl_service.DdlService/RisectlResumeBackfill" => {
4675                    #[allow(non_camel_case_types)]
4676                    struct RisectlResumeBackfillSvc<T: DdlService>(pub Arc<T>);
4677                    impl<
4678                        T: DdlService,
4679                    > tonic::server::UnaryService<super::RisectlResumeBackfillRequest>
4680                    for RisectlResumeBackfillSvc<T> {
4681                        type Response = super::RisectlResumeBackfillResponse;
4682                        type Future = BoxFuture<
4683                            tonic::Response<Self::Response>,
4684                            tonic::Status,
4685                        >;
4686                        fn call(
4687                            &mut self,
4688                            request: tonic::Request<super::RisectlResumeBackfillRequest>,
4689                        ) -> Self::Future {
4690                            let inner = Arc::clone(&self.0);
4691                            let fut = async move {
4692                                <T as DdlService>::risectl_resume_backfill(&inner, request)
4693                                    .await
4694                            };
4695                            Box::pin(fut)
4696                        }
4697                    }
4698                    let accept_compression_encodings = self.accept_compression_encodings;
4699                    let send_compression_encodings = self.send_compression_encodings;
4700                    let max_decoding_message_size = self.max_decoding_message_size;
4701                    let max_encoding_message_size = self.max_encoding_message_size;
4702                    let inner = self.inner.clone();
4703                    let fut = async move {
4704                        let method = RisectlResumeBackfillSvc(inner);
4705                        let codec = tonic_prost::ProstCodec::default();
4706                        let mut grpc = tonic::server::Grpc::new(codec)
4707                            .apply_compression_config(
4708                                accept_compression_encodings,
4709                                send_compression_encodings,
4710                            )
4711                            .apply_max_message_size_config(
4712                                max_decoding_message_size,
4713                                max_encoding_message_size,
4714                            );
4715                        let res = grpc.unary(method, req).await;
4716                        Ok(res)
4717                    };
4718                    Box::pin(fut)
4719                }
4720                "/ddl_service.DdlService/CreateView" => {
4721                    #[allow(non_camel_case_types)]
4722                    struct CreateViewSvc<T: DdlService>(pub Arc<T>);
4723                    impl<
4724                        T: DdlService,
4725                    > tonic::server::UnaryService<super::CreateViewRequest>
4726                    for CreateViewSvc<T> {
4727                        type Response = super::CreateViewResponse;
4728                        type Future = BoxFuture<
4729                            tonic::Response<Self::Response>,
4730                            tonic::Status,
4731                        >;
4732                        fn call(
4733                            &mut self,
4734                            request: tonic::Request<super::CreateViewRequest>,
4735                        ) -> Self::Future {
4736                            let inner = Arc::clone(&self.0);
4737                            let fut = async move {
4738                                <T as DdlService>::create_view(&inner, request).await
4739                            };
4740                            Box::pin(fut)
4741                        }
4742                    }
4743                    let accept_compression_encodings = self.accept_compression_encodings;
4744                    let send_compression_encodings = self.send_compression_encodings;
4745                    let max_decoding_message_size = self.max_decoding_message_size;
4746                    let max_encoding_message_size = self.max_encoding_message_size;
4747                    let inner = self.inner.clone();
4748                    let fut = async move {
4749                        let method = CreateViewSvc(inner);
4750                        let codec = tonic_prost::ProstCodec::default();
4751                        let mut grpc = tonic::server::Grpc::new(codec)
4752                            .apply_compression_config(
4753                                accept_compression_encodings,
4754                                send_compression_encodings,
4755                            )
4756                            .apply_max_message_size_config(
4757                                max_decoding_message_size,
4758                                max_encoding_message_size,
4759                            );
4760                        let res = grpc.unary(method, req).await;
4761                        Ok(res)
4762                    };
4763                    Box::pin(fut)
4764                }
4765                "/ddl_service.DdlService/DropView" => {
4766                    #[allow(non_camel_case_types)]
4767                    struct DropViewSvc<T: DdlService>(pub Arc<T>);
4768                    impl<
4769                        T: DdlService,
4770                    > tonic::server::UnaryService<super::DropViewRequest>
4771                    for DropViewSvc<T> {
4772                        type Response = super::DropViewResponse;
4773                        type Future = BoxFuture<
4774                            tonic::Response<Self::Response>,
4775                            tonic::Status,
4776                        >;
4777                        fn call(
4778                            &mut self,
4779                            request: tonic::Request<super::DropViewRequest>,
4780                        ) -> Self::Future {
4781                            let inner = Arc::clone(&self.0);
4782                            let fut = async move {
4783                                <T as DdlService>::drop_view(&inner, request).await
4784                            };
4785                            Box::pin(fut)
4786                        }
4787                    }
4788                    let accept_compression_encodings = self.accept_compression_encodings;
4789                    let send_compression_encodings = self.send_compression_encodings;
4790                    let max_decoding_message_size = self.max_decoding_message_size;
4791                    let max_encoding_message_size = self.max_encoding_message_size;
4792                    let inner = self.inner.clone();
4793                    let fut = async move {
4794                        let method = DropViewSvc(inner);
4795                        let codec = tonic_prost::ProstCodec::default();
4796                        let mut grpc = tonic::server::Grpc::new(codec)
4797                            .apply_compression_config(
4798                                accept_compression_encodings,
4799                                send_compression_encodings,
4800                            )
4801                            .apply_max_message_size_config(
4802                                max_decoding_message_size,
4803                                max_encoding_message_size,
4804                            );
4805                        let res = grpc.unary(method, req).await;
4806                        Ok(res)
4807                    };
4808                    Box::pin(fut)
4809                }
4810                "/ddl_service.DdlService/CreateIndex" => {
4811                    #[allow(non_camel_case_types)]
4812                    struct CreateIndexSvc<T: DdlService>(pub Arc<T>);
4813                    impl<
4814                        T: DdlService,
4815                    > tonic::server::UnaryService<super::CreateIndexRequest>
4816                    for CreateIndexSvc<T> {
4817                        type Response = super::CreateIndexResponse;
4818                        type Future = BoxFuture<
4819                            tonic::Response<Self::Response>,
4820                            tonic::Status,
4821                        >;
4822                        fn call(
4823                            &mut self,
4824                            request: tonic::Request<super::CreateIndexRequest>,
4825                        ) -> Self::Future {
4826                            let inner = Arc::clone(&self.0);
4827                            let fut = async move {
4828                                <T as DdlService>::create_index(&inner, request).await
4829                            };
4830                            Box::pin(fut)
4831                        }
4832                    }
4833                    let accept_compression_encodings = self.accept_compression_encodings;
4834                    let send_compression_encodings = self.send_compression_encodings;
4835                    let max_decoding_message_size = self.max_decoding_message_size;
4836                    let max_encoding_message_size = self.max_encoding_message_size;
4837                    let inner = self.inner.clone();
4838                    let fut = async move {
4839                        let method = CreateIndexSvc(inner);
4840                        let codec = tonic_prost::ProstCodec::default();
4841                        let mut grpc = tonic::server::Grpc::new(codec)
4842                            .apply_compression_config(
4843                                accept_compression_encodings,
4844                                send_compression_encodings,
4845                            )
4846                            .apply_max_message_size_config(
4847                                max_decoding_message_size,
4848                                max_encoding_message_size,
4849                            );
4850                        let res = grpc.unary(method, req).await;
4851                        Ok(res)
4852                    };
4853                    Box::pin(fut)
4854                }
4855                "/ddl_service.DdlService/DropIndex" => {
4856                    #[allow(non_camel_case_types)]
4857                    struct DropIndexSvc<T: DdlService>(pub Arc<T>);
4858                    impl<
4859                        T: DdlService,
4860                    > tonic::server::UnaryService<super::DropIndexRequest>
4861                    for DropIndexSvc<T> {
4862                        type Response = super::DropIndexResponse;
4863                        type Future = BoxFuture<
4864                            tonic::Response<Self::Response>,
4865                            tonic::Status,
4866                        >;
4867                        fn call(
4868                            &mut self,
4869                            request: tonic::Request<super::DropIndexRequest>,
4870                        ) -> Self::Future {
4871                            let inner = Arc::clone(&self.0);
4872                            let fut = async move {
4873                                <T as DdlService>::drop_index(&inner, request).await
4874                            };
4875                            Box::pin(fut)
4876                        }
4877                    }
4878                    let accept_compression_encodings = self.accept_compression_encodings;
4879                    let send_compression_encodings = self.send_compression_encodings;
4880                    let max_decoding_message_size = self.max_decoding_message_size;
4881                    let max_encoding_message_size = self.max_encoding_message_size;
4882                    let inner = self.inner.clone();
4883                    let fut = async move {
4884                        let method = DropIndexSvc(inner);
4885                        let codec = tonic_prost::ProstCodec::default();
4886                        let mut grpc = tonic::server::Grpc::new(codec)
4887                            .apply_compression_config(
4888                                accept_compression_encodings,
4889                                send_compression_encodings,
4890                            )
4891                            .apply_max_message_size_config(
4892                                max_decoding_message_size,
4893                                max_encoding_message_size,
4894                            );
4895                        let res = grpc.unary(method, req).await;
4896                        Ok(res)
4897                    };
4898                    Box::pin(fut)
4899                }
4900                "/ddl_service.DdlService/CreateFunction" => {
4901                    #[allow(non_camel_case_types)]
4902                    struct CreateFunctionSvc<T: DdlService>(pub Arc<T>);
4903                    impl<
4904                        T: DdlService,
4905                    > tonic::server::UnaryService<super::CreateFunctionRequest>
4906                    for CreateFunctionSvc<T> {
4907                        type Response = super::CreateFunctionResponse;
4908                        type Future = BoxFuture<
4909                            tonic::Response<Self::Response>,
4910                            tonic::Status,
4911                        >;
4912                        fn call(
4913                            &mut self,
4914                            request: tonic::Request<super::CreateFunctionRequest>,
4915                        ) -> Self::Future {
4916                            let inner = Arc::clone(&self.0);
4917                            let fut = async move {
4918                                <T as DdlService>::create_function(&inner, request).await
4919                            };
4920                            Box::pin(fut)
4921                        }
4922                    }
4923                    let accept_compression_encodings = self.accept_compression_encodings;
4924                    let send_compression_encodings = self.send_compression_encodings;
4925                    let max_decoding_message_size = self.max_decoding_message_size;
4926                    let max_encoding_message_size = self.max_encoding_message_size;
4927                    let inner = self.inner.clone();
4928                    let fut = async move {
4929                        let method = CreateFunctionSvc(inner);
4930                        let codec = tonic_prost::ProstCodec::default();
4931                        let mut grpc = tonic::server::Grpc::new(codec)
4932                            .apply_compression_config(
4933                                accept_compression_encodings,
4934                                send_compression_encodings,
4935                            )
4936                            .apply_max_message_size_config(
4937                                max_decoding_message_size,
4938                                max_encoding_message_size,
4939                            );
4940                        let res = grpc.unary(method, req).await;
4941                        Ok(res)
4942                    };
4943                    Box::pin(fut)
4944                }
4945                "/ddl_service.DdlService/DropFunction" => {
4946                    #[allow(non_camel_case_types)]
4947                    struct DropFunctionSvc<T: DdlService>(pub Arc<T>);
4948                    impl<
4949                        T: DdlService,
4950                    > tonic::server::UnaryService<super::DropFunctionRequest>
4951                    for DropFunctionSvc<T> {
4952                        type Response = super::DropFunctionResponse;
4953                        type Future = BoxFuture<
4954                            tonic::Response<Self::Response>,
4955                            tonic::Status,
4956                        >;
4957                        fn call(
4958                            &mut self,
4959                            request: tonic::Request<super::DropFunctionRequest>,
4960                        ) -> Self::Future {
4961                            let inner = Arc::clone(&self.0);
4962                            let fut = async move {
4963                                <T as DdlService>::drop_function(&inner, request).await
4964                            };
4965                            Box::pin(fut)
4966                        }
4967                    }
4968                    let accept_compression_encodings = self.accept_compression_encodings;
4969                    let send_compression_encodings = self.send_compression_encodings;
4970                    let max_decoding_message_size = self.max_decoding_message_size;
4971                    let max_encoding_message_size = self.max_encoding_message_size;
4972                    let inner = self.inner.clone();
4973                    let fut = async move {
4974                        let method = DropFunctionSvc(inner);
4975                        let codec = tonic_prost::ProstCodec::default();
4976                        let mut grpc = tonic::server::Grpc::new(codec)
4977                            .apply_compression_config(
4978                                accept_compression_encodings,
4979                                send_compression_encodings,
4980                            )
4981                            .apply_max_message_size_config(
4982                                max_decoding_message_size,
4983                                max_encoding_message_size,
4984                            );
4985                        let res = grpc.unary(method, req).await;
4986                        Ok(res)
4987                    };
4988                    Box::pin(fut)
4989                }
4990                "/ddl_service.DdlService/ReplaceJobPlan" => {
4991                    #[allow(non_camel_case_types)]
4992                    struct ReplaceJobPlanSvc<T: DdlService>(pub Arc<T>);
4993                    impl<
4994                        T: DdlService,
4995                    > tonic::server::UnaryService<super::ReplaceJobPlanRequest>
4996                    for ReplaceJobPlanSvc<T> {
4997                        type Response = super::ReplaceJobPlanResponse;
4998                        type Future = BoxFuture<
4999                            tonic::Response<Self::Response>,
5000                            tonic::Status,
5001                        >;
5002                        fn call(
5003                            &mut self,
5004                            request: tonic::Request<super::ReplaceJobPlanRequest>,
5005                        ) -> Self::Future {
5006                            let inner = Arc::clone(&self.0);
5007                            let fut = async move {
5008                                <T as DdlService>::replace_job_plan(&inner, request).await
5009                            };
5010                            Box::pin(fut)
5011                        }
5012                    }
5013                    let accept_compression_encodings = self.accept_compression_encodings;
5014                    let send_compression_encodings = self.send_compression_encodings;
5015                    let max_decoding_message_size = self.max_decoding_message_size;
5016                    let max_encoding_message_size = self.max_encoding_message_size;
5017                    let inner = self.inner.clone();
5018                    let fut = async move {
5019                        let method = ReplaceJobPlanSvc(inner);
5020                        let codec = tonic_prost::ProstCodec::default();
5021                        let mut grpc = tonic::server::Grpc::new(codec)
5022                            .apply_compression_config(
5023                                accept_compression_encodings,
5024                                send_compression_encodings,
5025                            )
5026                            .apply_max_message_size_config(
5027                                max_decoding_message_size,
5028                                max_encoding_message_size,
5029                            );
5030                        let res = grpc.unary(method, req).await;
5031                        Ok(res)
5032                    };
5033                    Box::pin(fut)
5034                }
5035                "/ddl_service.DdlService/GetTable" => {
5036                    #[allow(non_camel_case_types)]
5037                    struct GetTableSvc<T: DdlService>(pub Arc<T>);
5038                    impl<
5039                        T: DdlService,
5040                    > tonic::server::UnaryService<super::GetTableRequest>
5041                    for GetTableSvc<T> {
5042                        type Response = super::GetTableResponse;
5043                        type Future = BoxFuture<
5044                            tonic::Response<Self::Response>,
5045                            tonic::Status,
5046                        >;
5047                        fn call(
5048                            &mut self,
5049                            request: tonic::Request<super::GetTableRequest>,
5050                        ) -> Self::Future {
5051                            let inner = Arc::clone(&self.0);
5052                            let fut = async move {
5053                                <T as DdlService>::get_table(&inner, request).await
5054                            };
5055                            Box::pin(fut)
5056                        }
5057                    }
5058                    let accept_compression_encodings = self.accept_compression_encodings;
5059                    let send_compression_encodings = self.send_compression_encodings;
5060                    let max_decoding_message_size = self.max_decoding_message_size;
5061                    let max_encoding_message_size = self.max_encoding_message_size;
5062                    let inner = self.inner.clone();
5063                    let fut = async move {
5064                        let method = GetTableSvc(inner);
5065                        let codec = tonic_prost::ProstCodec::default();
5066                        let mut grpc = tonic::server::Grpc::new(codec)
5067                            .apply_compression_config(
5068                                accept_compression_encodings,
5069                                send_compression_encodings,
5070                            )
5071                            .apply_max_message_size_config(
5072                                max_decoding_message_size,
5073                                max_encoding_message_size,
5074                            );
5075                        let res = grpc.unary(method, req).await;
5076                        Ok(res)
5077                    };
5078                    Box::pin(fut)
5079                }
5080                "/ddl_service.DdlService/GetDdlProgress" => {
5081                    #[allow(non_camel_case_types)]
5082                    struct GetDdlProgressSvc<T: DdlService>(pub Arc<T>);
5083                    impl<
5084                        T: DdlService,
5085                    > tonic::server::UnaryService<super::GetDdlProgressRequest>
5086                    for GetDdlProgressSvc<T> {
5087                        type Response = super::GetDdlProgressResponse;
5088                        type Future = BoxFuture<
5089                            tonic::Response<Self::Response>,
5090                            tonic::Status,
5091                        >;
5092                        fn call(
5093                            &mut self,
5094                            request: tonic::Request<super::GetDdlProgressRequest>,
5095                        ) -> Self::Future {
5096                            let inner = Arc::clone(&self.0);
5097                            let fut = async move {
5098                                <T as DdlService>::get_ddl_progress(&inner, request).await
5099                            };
5100                            Box::pin(fut)
5101                        }
5102                    }
5103                    let accept_compression_encodings = self.accept_compression_encodings;
5104                    let send_compression_encodings = self.send_compression_encodings;
5105                    let max_decoding_message_size = self.max_decoding_message_size;
5106                    let max_encoding_message_size = self.max_encoding_message_size;
5107                    let inner = self.inner.clone();
5108                    let fut = async move {
5109                        let method = GetDdlProgressSvc(inner);
5110                        let codec = tonic_prost::ProstCodec::default();
5111                        let mut grpc = tonic::server::Grpc::new(codec)
5112                            .apply_compression_config(
5113                                accept_compression_encodings,
5114                                send_compression_encodings,
5115                            )
5116                            .apply_max_message_size_config(
5117                                max_decoding_message_size,
5118                                max_encoding_message_size,
5119                            );
5120                        let res = grpc.unary(method, req).await;
5121                        Ok(res)
5122                    };
5123                    Box::pin(fut)
5124                }
5125                "/ddl_service.DdlService/CreateConnection" => {
5126                    #[allow(non_camel_case_types)]
5127                    struct CreateConnectionSvc<T: DdlService>(pub Arc<T>);
5128                    impl<
5129                        T: DdlService,
5130                    > tonic::server::UnaryService<super::CreateConnectionRequest>
5131                    for CreateConnectionSvc<T> {
5132                        type Response = super::CreateConnectionResponse;
5133                        type Future = BoxFuture<
5134                            tonic::Response<Self::Response>,
5135                            tonic::Status,
5136                        >;
5137                        fn call(
5138                            &mut self,
5139                            request: tonic::Request<super::CreateConnectionRequest>,
5140                        ) -> Self::Future {
5141                            let inner = Arc::clone(&self.0);
5142                            let fut = async move {
5143                                <T as DdlService>::create_connection(&inner, request).await
5144                            };
5145                            Box::pin(fut)
5146                        }
5147                    }
5148                    let accept_compression_encodings = self.accept_compression_encodings;
5149                    let send_compression_encodings = self.send_compression_encodings;
5150                    let max_decoding_message_size = self.max_decoding_message_size;
5151                    let max_encoding_message_size = self.max_encoding_message_size;
5152                    let inner = self.inner.clone();
5153                    let fut = async move {
5154                        let method = CreateConnectionSvc(inner);
5155                        let codec = tonic_prost::ProstCodec::default();
5156                        let mut grpc = tonic::server::Grpc::new(codec)
5157                            .apply_compression_config(
5158                                accept_compression_encodings,
5159                                send_compression_encodings,
5160                            )
5161                            .apply_max_message_size_config(
5162                                max_decoding_message_size,
5163                                max_encoding_message_size,
5164                            );
5165                        let res = grpc.unary(method, req).await;
5166                        Ok(res)
5167                    };
5168                    Box::pin(fut)
5169                }
5170                "/ddl_service.DdlService/ListConnections" => {
5171                    #[allow(non_camel_case_types)]
5172                    struct ListConnectionsSvc<T: DdlService>(pub Arc<T>);
5173                    impl<
5174                        T: DdlService,
5175                    > tonic::server::UnaryService<super::ListConnectionsRequest>
5176                    for ListConnectionsSvc<T> {
5177                        type Response = super::ListConnectionsResponse;
5178                        type Future = BoxFuture<
5179                            tonic::Response<Self::Response>,
5180                            tonic::Status,
5181                        >;
5182                        fn call(
5183                            &mut self,
5184                            request: tonic::Request<super::ListConnectionsRequest>,
5185                        ) -> Self::Future {
5186                            let inner = Arc::clone(&self.0);
5187                            let fut = async move {
5188                                <T as DdlService>::list_connections(&inner, request).await
5189                            };
5190                            Box::pin(fut)
5191                        }
5192                    }
5193                    let accept_compression_encodings = self.accept_compression_encodings;
5194                    let send_compression_encodings = self.send_compression_encodings;
5195                    let max_decoding_message_size = self.max_decoding_message_size;
5196                    let max_encoding_message_size = self.max_encoding_message_size;
5197                    let inner = self.inner.clone();
5198                    let fut = async move {
5199                        let method = ListConnectionsSvc(inner);
5200                        let codec = tonic_prost::ProstCodec::default();
5201                        let mut grpc = tonic::server::Grpc::new(codec)
5202                            .apply_compression_config(
5203                                accept_compression_encodings,
5204                                send_compression_encodings,
5205                            )
5206                            .apply_max_message_size_config(
5207                                max_decoding_message_size,
5208                                max_encoding_message_size,
5209                            );
5210                        let res = grpc.unary(method, req).await;
5211                        Ok(res)
5212                    };
5213                    Box::pin(fut)
5214                }
5215                "/ddl_service.DdlService/DropConnection" => {
5216                    #[allow(non_camel_case_types)]
5217                    struct DropConnectionSvc<T: DdlService>(pub Arc<T>);
5218                    impl<
5219                        T: DdlService,
5220                    > tonic::server::UnaryService<super::DropConnectionRequest>
5221                    for DropConnectionSvc<T> {
5222                        type Response = super::DropConnectionResponse;
5223                        type Future = BoxFuture<
5224                            tonic::Response<Self::Response>,
5225                            tonic::Status,
5226                        >;
5227                        fn call(
5228                            &mut self,
5229                            request: tonic::Request<super::DropConnectionRequest>,
5230                        ) -> Self::Future {
5231                            let inner = Arc::clone(&self.0);
5232                            let fut = async move {
5233                                <T as DdlService>::drop_connection(&inner, request).await
5234                            };
5235                            Box::pin(fut)
5236                        }
5237                    }
5238                    let accept_compression_encodings = self.accept_compression_encodings;
5239                    let send_compression_encodings = self.send_compression_encodings;
5240                    let max_decoding_message_size = self.max_decoding_message_size;
5241                    let max_encoding_message_size = self.max_encoding_message_size;
5242                    let inner = self.inner.clone();
5243                    let fut = async move {
5244                        let method = DropConnectionSvc(inner);
5245                        let codec = tonic_prost::ProstCodec::default();
5246                        let mut grpc = tonic::server::Grpc::new(codec)
5247                            .apply_compression_config(
5248                                accept_compression_encodings,
5249                                send_compression_encodings,
5250                            )
5251                            .apply_max_message_size_config(
5252                                max_decoding_message_size,
5253                                max_encoding_message_size,
5254                            );
5255                        let res = grpc.unary(method, req).await;
5256                        Ok(res)
5257                    };
5258                    Box::pin(fut)
5259                }
5260                "/ddl_service.DdlService/GetTables" => {
5261                    #[allow(non_camel_case_types)]
5262                    struct GetTablesSvc<T: DdlService>(pub Arc<T>);
5263                    impl<
5264                        T: DdlService,
5265                    > tonic::server::UnaryService<super::GetTablesRequest>
5266                    for GetTablesSvc<T> {
5267                        type Response = super::GetTablesResponse;
5268                        type Future = BoxFuture<
5269                            tonic::Response<Self::Response>,
5270                            tonic::Status,
5271                        >;
5272                        fn call(
5273                            &mut self,
5274                            request: tonic::Request<super::GetTablesRequest>,
5275                        ) -> Self::Future {
5276                            let inner = Arc::clone(&self.0);
5277                            let fut = async move {
5278                                <T as DdlService>::get_tables(&inner, request).await
5279                            };
5280                            Box::pin(fut)
5281                        }
5282                    }
5283                    let accept_compression_encodings = self.accept_compression_encodings;
5284                    let send_compression_encodings = self.send_compression_encodings;
5285                    let max_decoding_message_size = self.max_decoding_message_size;
5286                    let max_encoding_message_size = self.max_encoding_message_size;
5287                    let inner = self.inner.clone();
5288                    let fut = async move {
5289                        let method = GetTablesSvc(inner);
5290                        let codec = tonic_prost::ProstCodec::default();
5291                        let mut grpc = tonic::server::Grpc::new(codec)
5292                            .apply_compression_config(
5293                                accept_compression_encodings,
5294                                send_compression_encodings,
5295                            )
5296                            .apply_max_message_size_config(
5297                                max_decoding_message_size,
5298                                max_encoding_message_size,
5299                            );
5300                        let res = grpc.unary(method, req).await;
5301                        Ok(res)
5302                    };
5303                    Box::pin(fut)
5304                }
5305                "/ddl_service.DdlService/Wait" => {
5306                    #[allow(non_camel_case_types)]
5307                    struct WaitSvc<T: DdlService>(pub Arc<T>);
5308                    impl<T: DdlService> tonic::server::UnaryService<super::WaitRequest>
5309                    for WaitSvc<T> {
5310                        type Response = super::WaitResponse;
5311                        type Future = BoxFuture<
5312                            tonic::Response<Self::Response>,
5313                            tonic::Status,
5314                        >;
5315                        fn call(
5316                            &mut self,
5317                            request: tonic::Request<super::WaitRequest>,
5318                        ) -> Self::Future {
5319                            let inner = Arc::clone(&self.0);
5320                            let fut = async move {
5321                                <T as DdlService>::wait(&inner, request).await
5322                            };
5323                            Box::pin(fut)
5324                        }
5325                    }
5326                    let accept_compression_encodings = self.accept_compression_encodings;
5327                    let send_compression_encodings = self.send_compression_encodings;
5328                    let max_decoding_message_size = self.max_decoding_message_size;
5329                    let max_encoding_message_size = self.max_encoding_message_size;
5330                    let inner = self.inner.clone();
5331                    let fut = async move {
5332                        let method = WaitSvc(inner);
5333                        let codec = tonic_prost::ProstCodec::default();
5334                        let mut grpc = tonic::server::Grpc::new(codec)
5335                            .apply_compression_config(
5336                                accept_compression_encodings,
5337                                send_compression_encodings,
5338                            )
5339                            .apply_max_message_size_config(
5340                                max_decoding_message_size,
5341                                max_encoding_message_size,
5342                            );
5343                        let res = grpc.unary(method, req).await;
5344                        Ok(res)
5345                    };
5346                    Box::pin(fut)
5347                }
5348                "/ddl_service.DdlService/CommentOn" => {
5349                    #[allow(non_camel_case_types)]
5350                    struct CommentOnSvc<T: DdlService>(pub Arc<T>);
5351                    impl<
5352                        T: DdlService,
5353                    > tonic::server::UnaryService<super::CommentOnRequest>
5354                    for CommentOnSvc<T> {
5355                        type Response = super::CommentOnResponse;
5356                        type Future = BoxFuture<
5357                            tonic::Response<Self::Response>,
5358                            tonic::Status,
5359                        >;
5360                        fn call(
5361                            &mut self,
5362                            request: tonic::Request<super::CommentOnRequest>,
5363                        ) -> Self::Future {
5364                            let inner = Arc::clone(&self.0);
5365                            let fut = async move {
5366                                <T as DdlService>::comment_on(&inner, request).await
5367                            };
5368                            Box::pin(fut)
5369                        }
5370                    }
5371                    let accept_compression_encodings = self.accept_compression_encodings;
5372                    let send_compression_encodings = self.send_compression_encodings;
5373                    let max_decoding_message_size = self.max_decoding_message_size;
5374                    let max_encoding_message_size = self.max_encoding_message_size;
5375                    let inner = self.inner.clone();
5376                    let fut = async move {
5377                        let method = CommentOnSvc(inner);
5378                        let codec = tonic_prost::ProstCodec::default();
5379                        let mut grpc = tonic::server::Grpc::new(codec)
5380                            .apply_compression_config(
5381                                accept_compression_encodings,
5382                                send_compression_encodings,
5383                            )
5384                            .apply_max_message_size_config(
5385                                max_decoding_message_size,
5386                                max_encoding_message_size,
5387                            );
5388                        let res = grpc.unary(method, req).await;
5389                        Ok(res)
5390                    };
5391                    Box::pin(fut)
5392                }
5393                "/ddl_service.DdlService/AutoSchemaChange" => {
5394                    #[allow(non_camel_case_types)]
5395                    struct AutoSchemaChangeSvc<T: DdlService>(pub Arc<T>);
5396                    impl<
5397                        T: DdlService,
5398                    > tonic::server::UnaryService<super::AutoSchemaChangeRequest>
5399                    for AutoSchemaChangeSvc<T> {
5400                        type Response = super::AutoSchemaChangeResponse;
5401                        type Future = BoxFuture<
5402                            tonic::Response<Self::Response>,
5403                            tonic::Status,
5404                        >;
5405                        fn call(
5406                            &mut self,
5407                            request: tonic::Request<super::AutoSchemaChangeRequest>,
5408                        ) -> Self::Future {
5409                            let inner = Arc::clone(&self.0);
5410                            let fut = async move {
5411                                <T as DdlService>::auto_schema_change(&inner, request).await
5412                            };
5413                            Box::pin(fut)
5414                        }
5415                    }
5416                    let accept_compression_encodings = self.accept_compression_encodings;
5417                    let send_compression_encodings = self.send_compression_encodings;
5418                    let max_decoding_message_size = self.max_decoding_message_size;
5419                    let max_encoding_message_size = self.max_encoding_message_size;
5420                    let inner = self.inner.clone();
5421                    let fut = async move {
5422                        let method = AutoSchemaChangeSvc(inner);
5423                        let codec = tonic_prost::ProstCodec::default();
5424                        let mut grpc = tonic::server::Grpc::new(codec)
5425                            .apply_compression_config(
5426                                accept_compression_encodings,
5427                                send_compression_encodings,
5428                            )
5429                            .apply_max_message_size_config(
5430                                max_decoding_message_size,
5431                                max_encoding_message_size,
5432                            );
5433                        let res = grpc.unary(method, req).await;
5434                        Ok(res)
5435                    };
5436                    Box::pin(fut)
5437                }
5438                "/ddl_service.DdlService/AlterSwapRename" => {
5439                    #[allow(non_camel_case_types)]
5440                    struct AlterSwapRenameSvc<T: DdlService>(pub Arc<T>);
5441                    impl<
5442                        T: DdlService,
5443                    > tonic::server::UnaryService<super::AlterSwapRenameRequest>
5444                    for AlterSwapRenameSvc<T> {
5445                        type Response = super::AlterSwapRenameResponse;
5446                        type Future = BoxFuture<
5447                            tonic::Response<Self::Response>,
5448                            tonic::Status,
5449                        >;
5450                        fn call(
5451                            &mut self,
5452                            request: tonic::Request<super::AlterSwapRenameRequest>,
5453                        ) -> Self::Future {
5454                            let inner = Arc::clone(&self.0);
5455                            let fut = async move {
5456                                <T as DdlService>::alter_swap_rename(&inner, request).await
5457                            };
5458                            Box::pin(fut)
5459                        }
5460                    }
5461                    let accept_compression_encodings = self.accept_compression_encodings;
5462                    let send_compression_encodings = self.send_compression_encodings;
5463                    let max_decoding_message_size = self.max_decoding_message_size;
5464                    let max_encoding_message_size = self.max_encoding_message_size;
5465                    let inner = self.inner.clone();
5466                    let fut = async move {
5467                        let method = AlterSwapRenameSvc(inner);
5468                        let codec = tonic_prost::ProstCodec::default();
5469                        let mut grpc = tonic::server::Grpc::new(codec)
5470                            .apply_compression_config(
5471                                accept_compression_encodings,
5472                                send_compression_encodings,
5473                            )
5474                            .apply_max_message_size_config(
5475                                max_decoding_message_size,
5476                                max_encoding_message_size,
5477                            );
5478                        let res = grpc.unary(method, req).await;
5479                        Ok(res)
5480                    };
5481                    Box::pin(fut)
5482                }
5483                "/ddl_service.DdlService/AlterDatabaseParam" => {
5484                    #[allow(non_camel_case_types)]
5485                    struct AlterDatabaseParamSvc<T: DdlService>(pub Arc<T>);
5486                    impl<
5487                        T: DdlService,
5488                    > tonic::server::UnaryService<super::AlterDatabaseParamRequest>
5489                    for AlterDatabaseParamSvc<T> {
5490                        type Response = super::AlterDatabaseParamResponse;
5491                        type Future = BoxFuture<
5492                            tonic::Response<Self::Response>,
5493                            tonic::Status,
5494                        >;
5495                        fn call(
5496                            &mut self,
5497                            request: tonic::Request<super::AlterDatabaseParamRequest>,
5498                        ) -> Self::Future {
5499                            let inner = Arc::clone(&self.0);
5500                            let fut = async move {
5501                                <T as DdlService>::alter_database_param(&inner, request)
5502                                    .await
5503                            };
5504                            Box::pin(fut)
5505                        }
5506                    }
5507                    let accept_compression_encodings = self.accept_compression_encodings;
5508                    let send_compression_encodings = self.send_compression_encodings;
5509                    let max_decoding_message_size = self.max_decoding_message_size;
5510                    let max_encoding_message_size = self.max_encoding_message_size;
5511                    let inner = self.inner.clone();
5512                    let fut = async move {
5513                        let method = AlterDatabaseParamSvc(inner);
5514                        let codec = tonic_prost::ProstCodec::default();
5515                        let mut grpc = tonic::server::Grpc::new(codec)
5516                            .apply_compression_config(
5517                                accept_compression_encodings,
5518                                send_compression_encodings,
5519                            )
5520                            .apply_max_message_size_config(
5521                                max_decoding_message_size,
5522                                max_encoding_message_size,
5523                            );
5524                        let res = grpc.unary(method, req).await;
5525                        Ok(res)
5526                    };
5527                    Box::pin(fut)
5528                }
5529                "/ddl_service.DdlService/CompactIcebergTable" => {
5530                    #[allow(non_camel_case_types)]
5531                    struct CompactIcebergTableSvc<T: DdlService>(pub Arc<T>);
5532                    impl<
5533                        T: DdlService,
5534                    > tonic::server::UnaryService<super::CompactIcebergTableRequest>
5535                    for CompactIcebergTableSvc<T> {
5536                        type Response = super::CompactIcebergTableResponse;
5537                        type Future = BoxFuture<
5538                            tonic::Response<Self::Response>,
5539                            tonic::Status,
5540                        >;
5541                        fn call(
5542                            &mut self,
5543                            request: tonic::Request<super::CompactIcebergTableRequest>,
5544                        ) -> Self::Future {
5545                            let inner = Arc::clone(&self.0);
5546                            let fut = async move {
5547                                <T as DdlService>::compact_iceberg_table(&inner, request)
5548                                    .await
5549                            };
5550                            Box::pin(fut)
5551                        }
5552                    }
5553                    let accept_compression_encodings = self.accept_compression_encodings;
5554                    let send_compression_encodings = self.send_compression_encodings;
5555                    let max_decoding_message_size = self.max_decoding_message_size;
5556                    let max_encoding_message_size = self.max_encoding_message_size;
5557                    let inner = self.inner.clone();
5558                    let fut = async move {
5559                        let method = CompactIcebergTableSvc(inner);
5560                        let codec = tonic_prost::ProstCodec::default();
5561                        let mut grpc = tonic::server::Grpc::new(codec)
5562                            .apply_compression_config(
5563                                accept_compression_encodings,
5564                                send_compression_encodings,
5565                            )
5566                            .apply_max_message_size_config(
5567                                max_decoding_message_size,
5568                                max_encoding_message_size,
5569                            );
5570                        let res = grpc.unary(method, req).await;
5571                        Ok(res)
5572                    };
5573                    Box::pin(fut)
5574                }
5575                "/ddl_service.DdlService/RewriteIcebergTableManifests" => {
5576                    #[allow(non_camel_case_types)]
5577                    struct RewriteIcebergTableManifestsSvc<T: DdlService>(pub Arc<T>);
5578                    impl<
5579                        T: DdlService,
5580                    > tonic::server::UnaryService<
5581                        super::RewriteIcebergTableManifestsRequest,
5582                    > for RewriteIcebergTableManifestsSvc<T> {
5583                        type Response = super::RewriteIcebergTableManifestsResponse;
5584                        type Future = BoxFuture<
5585                            tonic::Response<Self::Response>,
5586                            tonic::Status,
5587                        >;
5588                        fn call(
5589                            &mut self,
5590                            request: tonic::Request<
5591                                super::RewriteIcebergTableManifestsRequest,
5592                            >,
5593                        ) -> Self::Future {
5594                            let inner = Arc::clone(&self.0);
5595                            let fut = async move {
5596                                <T as DdlService>::rewrite_iceberg_table_manifests(
5597                                        &inner,
5598                                        request,
5599                                    )
5600                                    .await
5601                            };
5602                            Box::pin(fut)
5603                        }
5604                    }
5605                    let accept_compression_encodings = self.accept_compression_encodings;
5606                    let send_compression_encodings = self.send_compression_encodings;
5607                    let max_decoding_message_size = self.max_decoding_message_size;
5608                    let max_encoding_message_size = self.max_encoding_message_size;
5609                    let inner = self.inner.clone();
5610                    let fut = async move {
5611                        let method = RewriteIcebergTableManifestsSvc(inner);
5612                        let codec = tonic_prost::ProstCodec::default();
5613                        let mut grpc = tonic::server::Grpc::new(codec)
5614                            .apply_compression_config(
5615                                accept_compression_encodings,
5616                                send_compression_encodings,
5617                            )
5618                            .apply_max_message_size_config(
5619                                max_decoding_message_size,
5620                                max_encoding_message_size,
5621                            );
5622                        let res = grpc.unary(method, req).await;
5623                        Ok(res)
5624                    };
5625                    Box::pin(fut)
5626                }
5627                "/ddl_service.DdlService/ExpireIcebergTableSnapshots" => {
5628                    #[allow(non_camel_case_types)]
5629                    struct ExpireIcebergTableSnapshotsSvc<T: DdlService>(pub Arc<T>);
5630                    impl<
5631                        T: DdlService,
5632                    > tonic::server::UnaryService<
5633                        super::ExpireIcebergTableSnapshotsRequest,
5634                    > for ExpireIcebergTableSnapshotsSvc<T> {
5635                        type Response = super::ExpireIcebergTableSnapshotsResponse;
5636                        type Future = BoxFuture<
5637                            tonic::Response<Self::Response>,
5638                            tonic::Status,
5639                        >;
5640                        fn call(
5641                            &mut self,
5642                            request: tonic::Request<
5643                                super::ExpireIcebergTableSnapshotsRequest,
5644                            >,
5645                        ) -> Self::Future {
5646                            let inner = Arc::clone(&self.0);
5647                            let fut = async move {
5648                                <T as DdlService>::expire_iceberg_table_snapshots(
5649                                        &inner,
5650                                        request,
5651                                    )
5652                                    .await
5653                            };
5654                            Box::pin(fut)
5655                        }
5656                    }
5657                    let accept_compression_encodings = self.accept_compression_encodings;
5658                    let send_compression_encodings = self.send_compression_encodings;
5659                    let max_decoding_message_size = self.max_decoding_message_size;
5660                    let max_encoding_message_size = self.max_encoding_message_size;
5661                    let inner = self.inner.clone();
5662                    let fut = async move {
5663                        let method = ExpireIcebergTableSnapshotsSvc(inner);
5664                        let codec = tonic_prost::ProstCodec::default();
5665                        let mut grpc = tonic::server::Grpc::new(codec)
5666                            .apply_compression_config(
5667                                accept_compression_encodings,
5668                                send_compression_encodings,
5669                            )
5670                            .apply_max_message_size_config(
5671                                max_decoding_message_size,
5672                                max_encoding_message_size,
5673                            );
5674                        let res = grpc.unary(method, req).await;
5675                        Ok(res)
5676                    };
5677                    Box::pin(fut)
5678                }
5679                "/ddl_service.DdlService/RemoveIcebergTableOrphanFiles" => {
5680                    #[allow(non_camel_case_types)]
5681                    struct RemoveIcebergTableOrphanFilesSvc<T: DdlService>(pub Arc<T>);
5682                    impl<
5683                        T: DdlService,
5684                    > tonic::server::UnaryService<
5685                        super::RemoveIcebergTableOrphanFilesRequest,
5686                    > for RemoveIcebergTableOrphanFilesSvc<T> {
5687                        type Response = super::RemoveIcebergTableOrphanFilesResponse;
5688                        type Future = BoxFuture<
5689                            tonic::Response<Self::Response>,
5690                            tonic::Status,
5691                        >;
5692                        fn call(
5693                            &mut self,
5694                            request: tonic::Request<
5695                                super::RemoveIcebergTableOrphanFilesRequest,
5696                            >,
5697                        ) -> Self::Future {
5698                            let inner = Arc::clone(&self.0);
5699                            let fut = async move {
5700                                <T as DdlService>::remove_iceberg_table_orphan_files(
5701                                        &inner,
5702                                        request,
5703                                    )
5704                                    .await
5705                            };
5706                            Box::pin(fut)
5707                        }
5708                    }
5709                    let accept_compression_encodings = self.accept_compression_encodings;
5710                    let send_compression_encodings = self.send_compression_encodings;
5711                    let max_decoding_message_size = self.max_decoding_message_size;
5712                    let max_encoding_message_size = self.max_encoding_message_size;
5713                    let inner = self.inner.clone();
5714                    let fut = async move {
5715                        let method = RemoveIcebergTableOrphanFilesSvc(inner);
5716                        let codec = tonic_prost::ProstCodec::default();
5717                        let mut grpc = tonic::server::Grpc::new(codec)
5718                            .apply_compression_config(
5719                                accept_compression_encodings,
5720                                send_compression_encodings,
5721                            )
5722                            .apply_max_message_size_config(
5723                                max_decoding_message_size,
5724                                max_encoding_message_size,
5725                            );
5726                        let res = grpc.unary(method, req).await;
5727                        Ok(res)
5728                    };
5729                    Box::pin(fut)
5730                }
5731                "/ddl_service.DdlService/AlterCdcTableBackfillParallelism" => {
5732                    #[allow(non_camel_case_types)]
5733                    struct AlterCdcTableBackfillParallelismSvc<T: DdlService>(
5734                        pub Arc<T>,
5735                    );
5736                    impl<
5737                        T: DdlService,
5738                    > tonic::server::UnaryService<
5739                        super::AlterCdcTableBackfillParallelismRequest,
5740                    > for AlterCdcTableBackfillParallelismSvc<T> {
5741                        type Response = super::AlterCdcTableBackfillParallelismResponse;
5742                        type Future = BoxFuture<
5743                            tonic::Response<Self::Response>,
5744                            tonic::Status,
5745                        >;
5746                        fn call(
5747                            &mut self,
5748                            request: tonic::Request<
5749                                super::AlterCdcTableBackfillParallelismRequest,
5750                            >,
5751                        ) -> Self::Future {
5752                            let inner = Arc::clone(&self.0);
5753                            let fut = async move {
5754                                <T as DdlService>::alter_cdc_table_backfill_parallelism(
5755                                        &inner,
5756                                        request,
5757                                    )
5758                                    .await
5759                            };
5760                            Box::pin(fut)
5761                        }
5762                    }
5763                    let accept_compression_encodings = self.accept_compression_encodings;
5764                    let send_compression_encodings = self.send_compression_encodings;
5765                    let max_decoding_message_size = self.max_decoding_message_size;
5766                    let max_encoding_message_size = self.max_encoding_message_size;
5767                    let inner = self.inner.clone();
5768                    let fut = async move {
5769                        let method = AlterCdcTableBackfillParallelismSvc(inner);
5770                        let codec = tonic_prost::ProstCodec::default();
5771                        let mut grpc = tonic::server::Grpc::new(codec)
5772                            .apply_compression_config(
5773                                accept_compression_encodings,
5774                                send_compression_encodings,
5775                            )
5776                            .apply_max_message_size_config(
5777                                max_decoding_message_size,
5778                                max_encoding_message_size,
5779                            );
5780                        let res = grpc.unary(method, req).await;
5781                        Ok(res)
5782                    };
5783                    Box::pin(fut)
5784                }
5785                "/ddl_service.DdlService/AlterStreamingJobConfig" => {
5786                    #[allow(non_camel_case_types)]
5787                    struct AlterStreamingJobConfigSvc<T: DdlService>(pub Arc<T>);
5788                    impl<
5789                        T: DdlService,
5790                    > tonic::server::UnaryService<super::AlterStreamingJobConfigRequest>
5791                    for AlterStreamingJobConfigSvc<T> {
5792                        type Response = super::AlterStreamingJobConfigResponse;
5793                        type Future = BoxFuture<
5794                            tonic::Response<Self::Response>,
5795                            tonic::Status,
5796                        >;
5797                        fn call(
5798                            &mut self,
5799                            request: tonic::Request<
5800                                super::AlterStreamingJobConfigRequest,
5801                            >,
5802                        ) -> Self::Future {
5803                            let inner = Arc::clone(&self.0);
5804                            let fut = async move {
5805                                <T as DdlService>::alter_streaming_job_config(
5806                                        &inner,
5807                                        request,
5808                                    )
5809                                    .await
5810                            };
5811                            Box::pin(fut)
5812                        }
5813                    }
5814                    let accept_compression_encodings = self.accept_compression_encodings;
5815                    let send_compression_encodings = self.send_compression_encodings;
5816                    let max_decoding_message_size = self.max_decoding_message_size;
5817                    let max_encoding_message_size = self.max_encoding_message_size;
5818                    let inner = self.inner.clone();
5819                    let fut = async move {
5820                        let method = AlterStreamingJobConfigSvc(inner);
5821                        let codec = tonic_prost::ProstCodec::default();
5822                        let mut grpc = tonic::server::Grpc::new(codec)
5823                            .apply_compression_config(
5824                                accept_compression_encodings,
5825                                send_compression_encodings,
5826                            )
5827                            .apply_max_message_size_config(
5828                                max_decoding_message_size,
5829                                max_encoding_message_size,
5830                            );
5831                        let res = grpc.unary(method, req).await;
5832                        Ok(res)
5833                    };
5834                    Box::pin(fut)
5835                }
5836                "/ddl_service.DdlService/WaitIcebergPkIndexSinkEpoch" => {
5837                    #[allow(non_camel_case_types)]
5838                    struct WaitIcebergPkIndexSinkEpochSvc<T: DdlService>(pub Arc<T>);
5839                    impl<
5840                        T: DdlService,
5841                    > tonic::server::UnaryService<
5842                        super::WaitIcebergPkIndexSinkEpochRequest,
5843                    > for WaitIcebergPkIndexSinkEpochSvc<T> {
5844                        type Response = super::WaitIcebergPkIndexSinkEpochResponse;
5845                        type Future = BoxFuture<
5846                            tonic::Response<Self::Response>,
5847                            tonic::Status,
5848                        >;
5849                        fn call(
5850                            &mut self,
5851                            request: tonic::Request<
5852                                super::WaitIcebergPkIndexSinkEpochRequest,
5853                            >,
5854                        ) -> Self::Future {
5855                            let inner = Arc::clone(&self.0);
5856                            let fut = async move {
5857                                <T as DdlService>::wait_iceberg_pk_index_sink_epoch(
5858                                        &inner,
5859                                        request,
5860                                    )
5861                                    .await
5862                            };
5863                            Box::pin(fut)
5864                        }
5865                    }
5866                    let accept_compression_encodings = self.accept_compression_encodings;
5867                    let send_compression_encodings = self.send_compression_encodings;
5868                    let max_decoding_message_size = self.max_decoding_message_size;
5869                    let max_encoding_message_size = self.max_encoding_message_size;
5870                    let inner = self.inner.clone();
5871                    let fut = async move {
5872                        let method = WaitIcebergPkIndexSinkEpochSvc(inner);
5873                        let codec = tonic_prost::ProstCodec::default();
5874                        let mut grpc = tonic::server::Grpc::new(codec)
5875                            .apply_compression_config(
5876                                accept_compression_encodings,
5877                                send_compression_encodings,
5878                            )
5879                            .apply_max_message_size_config(
5880                                max_decoding_message_size,
5881                                max_encoding_message_size,
5882                            );
5883                        let res = grpc.unary(method, req).await;
5884                        Ok(res)
5885                    };
5886                    Box::pin(fut)
5887                }
5888                _ => {
5889                    Box::pin(async move {
5890                        let mut response = http::Response::new(
5891                            tonic::body::Body::default(),
5892                        );
5893                        let headers = response.headers_mut();
5894                        headers
5895                            .insert(
5896                                tonic::Status::GRPC_STATUS,
5897                                (tonic::Code::Unimplemented as i32).into(),
5898                            );
5899                        headers
5900                            .insert(
5901                                http::header::CONTENT_TYPE,
5902                                tonic::metadata::GRPC_CONTENT_TYPE,
5903                            );
5904                        Ok(response)
5905                    })
5906                }
5907            }
5908        }
5909    }
5910    impl<T> Clone for DdlServiceServer<T> {
5911        fn clone(&self) -> Self {
5912            let inner = self.inner.clone();
5913            Self {
5914                inner,
5915                accept_compression_encodings: self.accept_compression_encodings,
5916                send_compression_encodings: self.send_compression_encodings,
5917                max_decoding_message_size: self.max_decoding_message_size,
5918                max_encoding_message_size: self.max_encoding_message_size,
5919            }
5920        }
5921    }
5922    /// Generated gRPC service name
5923    pub const SERVICE_NAME: &str = "ddl_service.DdlService";
5924    impl<T> tonic::server::NamedService for DdlServiceServer<T> {
5925        const NAME: &'static str = SERVICE_NAME;
5926    }
5927}
risingwave_pb/ddl_service.rs

risingwave_pb/
ddl_service.rs
