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")]
1176    pub task_id: u64,
1177}
1178#[derive(prost_helpers::AnyPB)]
1179#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1180pub struct ExpireIcebergTableSnapshotsRequest {
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 ExpireIcebergTableSnapshotsResponse {
1187    #[prost(message, optional, tag = "1")]
1188    pub status: ::core::option::Option<super::common::Status>,
1189}
1190#[derive(prost_helpers::AnyPB)]
1191#[derive(Clone, PartialEq, ::prost::Message)]
1192pub struct AlterStreamingJobConfigRequest {
1193    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
1194    pub job_id: crate::id::JobId,
1195    #[prost(map = "string, string", tag = "2")]
1196    pub entries_to_add: ::std::collections::HashMap<
1197        ::prost::alloc::string::String,
1198        ::prost::alloc::string::String,
1199    >,
1200    #[prost(string, repeated, tag = "3")]
1201    pub keys_to_remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1202}
1203#[derive(prost_helpers::AnyPB)]
1204#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1205pub struct AlterStreamingJobConfigResponse {}
1206/// An enum to distinguish different types of the `Table` streaming job.
1207///
1208/// * GENERAL: Table streaming jobs w/ or w/o a connector
1209/// * SHARED_CDC_SOURCE: The table streaming job is created based on a shared CDC source job (risingwavelabs/rfcs#73).
1210///
1211/// And one may add other types to support Table jobs that based on other shared sources (risingwavelabs/rfcs#72).
1212///
1213/// Currently, it's usages include:
1214///
1215/// * When creating the streaming actor graph, different table jobs may need different treatment.
1216/// * Some adhoc validation when creating the streaming job. e.g., `validate_cdc_table`.
1217///
1218/// It's not included in `catalog.Table`, and thus not persisted. It's only used in the `CreateTableRequest`.
1219#[derive(prost_helpers::AnyPB)]
1220#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1221#[repr(i32)]
1222pub enum TableJobType {
1223    Unspecified = 0,
1224    /// table streaming jobs excepts the `SHARED_CDC_SOURCE` type
1225    General = 1,
1226    /// table streaming job sharing a CDC source job
1227    SharedCdcSource = 2,
1228}
1229impl TableJobType {
1230    /// String value of the enum field names used in the ProtoBuf definition.
1231    ///
1232    /// The values are not transformed in any way and thus are considered stable
1233    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1234    pub fn as_str_name(&self) -> &'static str {
1235        match self {
1236            Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
1237            Self::General => "TABLE_JOB_TYPE_GENERAL",
1238            Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
1239        }
1240    }
1241    /// Creates an enum from field names used in the ProtoBuf definition.
1242    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1243        match value {
1244            "TABLE_JOB_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
1245            "TABLE_JOB_TYPE_GENERAL" => Some(Self::General),
1246            "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Some(Self::SharedCdcSource),
1247            _ => None,
1248        }
1249    }
1250}
1251#[derive(prost_helpers::AnyPB)]
1252#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1253#[repr(i32)]
1254pub enum BackfillType {
1255    Unspecified = 0,
1256    NormalBackfill = 1,
1257    SnapshotBackfill = 2,
1258}
1259impl BackfillType {
1260    /// String value of the enum field names used in the ProtoBuf definition.
1261    ///
1262    /// The values are not transformed in any way and thus are considered stable
1263    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1264    pub fn as_str_name(&self) -> &'static str {
1265        match self {
1266            Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
1267            Self::NormalBackfill => "NORMAL_BACKFILL",
1268            Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
1269        }
1270    }
1271    /// Creates an enum from field names used in the ProtoBuf definition.
1272    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1273        match value {
1274            "BACKFILL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
1275            "NORMAL_BACKFILL" => Some(Self::NormalBackfill),
1276            "SNAPSHOT_BACKFILL" => Some(Self::SnapshotBackfill),
1277            _ => None,
1278        }
1279    }
1280}
1281/// Generated client implementations.
1282pub mod ddl_service_client {
1283    #![allow(
1284        unused_variables,
1285        dead_code,
1286        missing_docs,
1287        clippy::wildcard_imports,
1288        clippy::let_unit_value,
1289    )]
1290    use tonic::codegen::*;
1291    use tonic::codegen::http::Uri;
1292    #[derive(Debug, Clone)]
1293    pub struct DdlServiceClient<T> {
1294        inner: tonic::client::Grpc<T>,
1295    }
1296    impl DdlServiceClient<tonic::transport::Channel> {
1297        /// Attempt to create a new client by connecting to a given endpoint.
1298        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1299        where
1300            D: TryInto<tonic::transport::Endpoint>,
1301            D::Error: Into<StdError>,
1302        {
1303            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1304            Ok(Self::new(conn))
1305        }
1306    }
1307    impl<T> DdlServiceClient<T>
1308    where
1309        T: tonic::client::GrpcService<tonic::body::Body>,
1310        T::Error: Into<StdError>,
1311        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
1312        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
1313    {
1314        pub fn new(inner: T) -> Self {
1315            let inner = tonic::client::Grpc::new(inner);
1316            Self { inner }
1317        }
1318        pub fn with_origin(inner: T, origin: Uri) -> Self {
1319            let inner = tonic::client::Grpc::with_origin(inner, origin);
1320            Self { inner }
1321        }
1322        pub fn with_interceptor<F>(
1323            inner: T,
1324            interceptor: F,
1325        ) -> DdlServiceClient<InterceptedService<T, F>>
1326        where
1327            F: tonic::service::Interceptor,
1328            T::ResponseBody: Default,
1329            T: tonic::codegen::Service<
1330                http::Request<tonic::body::Body>,
1331                Response = http::Response<
1332                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
1333                >,
1334            >,
1335            <T as tonic::codegen::Service<
1336                http::Request<tonic::body::Body>,
1337            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
1338        {
1339            DdlServiceClient::new(InterceptedService::new(inner, interceptor))
1340        }
1341        /// Compress requests with the given encoding.
1342        ///
1343        /// This requires the server to support it otherwise it might respond with an
1344        /// error.
1345        #[must_use]
1346        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1347            self.inner = self.inner.send_compressed(encoding);
1348            self
1349        }
1350        /// Enable decompressing responses.
1351        #[must_use]
1352        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1353            self.inner = self.inner.accept_compressed(encoding);
1354            self
1355        }
1356        /// Limits the maximum size of a decoded message.
1357        ///
1358        /// Default: `4MB`
1359        #[must_use]
1360        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1361            self.inner = self.inner.max_decoding_message_size(limit);
1362            self
1363        }
1364        /// Limits the maximum size of an encoded message.
1365        ///
1366        /// Default: `usize::MAX`
1367        #[must_use]
1368        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1369            self.inner = self.inner.max_encoding_message_size(limit);
1370            self
1371        }
1372        pub async fn create_database(
1373            &mut self,
1374            request: impl tonic::IntoRequest<super::CreateDatabaseRequest>,
1375        ) -> std::result::Result<
1376            tonic::Response<super::CreateDatabaseResponse>,
1377            tonic::Status,
1378        > {
1379            self.inner
1380                .ready()
1381                .await
1382                .map_err(|e| {
1383                    tonic::Status::unknown(
1384                        format!("Service was not ready: {}", e.into()),
1385                    )
1386                })?;
1387            let codec = tonic_prost::ProstCodec::default();
1388            let path = http::uri::PathAndQuery::from_static(
1389                "/ddl_service.DdlService/CreateDatabase",
1390            );
1391            let mut req = request.into_request();
1392            req.extensions_mut()
1393                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateDatabase"));
1394            self.inner.unary(req, path, codec).await
1395        }
1396        pub async fn drop_database(
1397            &mut self,
1398            request: impl tonic::IntoRequest<super::DropDatabaseRequest>,
1399        ) -> std::result::Result<
1400            tonic::Response<super::DropDatabaseResponse>,
1401            tonic::Status,
1402        > {
1403            self.inner
1404                .ready()
1405                .await
1406                .map_err(|e| {
1407                    tonic::Status::unknown(
1408                        format!("Service was not ready: {}", e.into()),
1409                    )
1410                })?;
1411            let codec = tonic_prost::ProstCodec::default();
1412            let path = http::uri::PathAndQuery::from_static(
1413                "/ddl_service.DdlService/DropDatabase",
1414            );
1415            let mut req = request.into_request();
1416            req.extensions_mut()
1417                .insert(GrpcMethod::new("ddl_service.DdlService", "DropDatabase"));
1418            self.inner.unary(req, path, codec).await
1419        }
1420        pub async fn create_schema(
1421            &mut self,
1422            request: impl tonic::IntoRequest<super::CreateSchemaRequest>,
1423        ) -> std::result::Result<
1424            tonic::Response<super::CreateSchemaResponse>,
1425            tonic::Status,
1426        > {
1427            self.inner
1428                .ready()
1429                .await
1430                .map_err(|e| {
1431                    tonic::Status::unknown(
1432                        format!("Service was not ready: {}", e.into()),
1433                    )
1434                })?;
1435            let codec = tonic_prost::ProstCodec::default();
1436            let path = http::uri::PathAndQuery::from_static(
1437                "/ddl_service.DdlService/CreateSchema",
1438            );
1439            let mut req = request.into_request();
1440            req.extensions_mut()
1441                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSchema"));
1442            self.inner.unary(req, path, codec).await
1443        }
1444        pub async fn drop_schema(
1445            &mut self,
1446            request: impl tonic::IntoRequest<super::DropSchemaRequest>,
1447        ) -> std::result::Result<
1448            tonic::Response<super::DropSchemaResponse>,
1449            tonic::Status,
1450        > {
1451            self.inner
1452                .ready()
1453                .await
1454                .map_err(|e| {
1455                    tonic::Status::unknown(
1456                        format!("Service was not ready: {}", e.into()),
1457                    )
1458                })?;
1459            let codec = tonic_prost::ProstCodec::default();
1460            let path = http::uri::PathAndQuery::from_static(
1461                "/ddl_service.DdlService/DropSchema",
1462            );
1463            let mut req = request.into_request();
1464            req.extensions_mut()
1465                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSchema"));
1466            self.inner.unary(req, path, codec).await
1467        }
1468        pub async fn create_source(
1469            &mut self,
1470            request: impl tonic::IntoRequest<super::CreateSourceRequest>,
1471        ) -> std::result::Result<
1472            tonic::Response<super::CreateSourceResponse>,
1473            tonic::Status,
1474        > {
1475            self.inner
1476                .ready()
1477                .await
1478                .map_err(|e| {
1479                    tonic::Status::unknown(
1480                        format!("Service was not ready: {}", e.into()),
1481                    )
1482                })?;
1483            let codec = tonic_prost::ProstCodec::default();
1484            let path = http::uri::PathAndQuery::from_static(
1485                "/ddl_service.DdlService/CreateSource",
1486            );
1487            let mut req = request.into_request();
1488            req.extensions_mut()
1489                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSource"));
1490            self.inner.unary(req, path, codec).await
1491        }
1492        pub async fn drop_source(
1493            &mut self,
1494            request: impl tonic::IntoRequest<super::DropSourceRequest>,
1495        ) -> std::result::Result<
1496            tonic::Response<super::DropSourceResponse>,
1497            tonic::Status,
1498        > {
1499            self.inner
1500                .ready()
1501                .await
1502                .map_err(|e| {
1503                    tonic::Status::unknown(
1504                        format!("Service was not ready: {}", e.into()),
1505                    )
1506                })?;
1507            let codec = tonic_prost::ProstCodec::default();
1508            let path = http::uri::PathAndQuery::from_static(
1509                "/ddl_service.DdlService/DropSource",
1510            );
1511            let mut req = request.into_request();
1512            req.extensions_mut()
1513                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSource"));
1514            self.inner.unary(req, path, codec).await
1515        }
1516        pub async fn create_sink(
1517            &mut self,
1518            request: impl tonic::IntoRequest<super::CreateSinkRequest>,
1519        ) -> std::result::Result<
1520            tonic::Response<super::CreateSinkResponse>,
1521            tonic::Status,
1522        > {
1523            self.inner
1524                .ready()
1525                .await
1526                .map_err(|e| {
1527                    tonic::Status::unknown(
1528                        format!("Service was not ready: {}", e.into()),
1529                    )
1530                })?;
1531            let codec = tonic_prost::ProstCodec::default();
1532            let path = http::uri::PathAndQuery::from_static(
1533                "/ddl_service.DdlService/CreateSink",
1534            );
1535            let mut req = request.into_request();
1536            req.extensions_mut()
1537                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSink"));
1538            self.inner.unary(req, path, codec).await
1539        }
1540        pub async fn create_subscription(
1541            &mut self,
1542            request: impl tonic::IntoRequest<super::CreateSubscriptionRequest>,
1543        ) -> std::result::Result<
1544            tonic::Response<super::CreateSubscriptionResponse>,
1545            tonic::Status,
1546        > {
1547            self.inner
1548                .ready()
1549                .await
1550                .map_err(|e| {
1551                    tonic::Status::unknown(
1552                        format!("Service was not ready: {}", e.into()),
1553                    )
1554                })?;
1555            let codec = tonic_prost::ProstCodec::default();
1556            let path = http::uri::PathAndQuery::from_static(
1557                "/ddl_service.DdlService/CreateSubscription",
1558            );
1559            let mut req = request.into_request();
1560            req.extensions_mut()
1561                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSubscription"));
1562            self.inner.unary(req, path, codec).await
1563        }
1564        pub async fn drop_sink(
1565            &mut self,
1566            request: impl tonic::IntoRequest<super::DropSinkRequest>,
1567        ) -> std::result::Result<
1568            tonic::Response<super::DropSinkResponse>,
1569            tonic::Status,
1570        > {
1571            self.inner
1572                .ready()
1573                .await
1574                .map_err(|e| {
1575                    tonic::Status::unknown(
1576                        format!("Service was not ready: {}", e.into()),
1577                    )
1578                })?;
1579            let codec = tonic_prost::ProstCodec::default();
1580            let path = http::uri::PathAndQuery::from_static(
1581                "/ddl_service.DdlService/DropSink",
1582            );
1583            let mut req = request.into_request();
1584            req.extensions_mut()
1585                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSink"));
1586            self.inner.unary(req, path, codec).await
1587        }
1588        pub async fn drop_subscription(
1589            &mut self,
1590            request: impl tonic::IntoRequest<super::DropSubscriptionRequest>,
1591        ) -> std::result::Result<
1592            tonic::Response<super::DropSubscriptionResponse>,
1593            tonic::Status,
1594        > {
1595            self.inner
1596                .ready()
1597                .await
1598                .map_err(|e| {
1599                    tonic::Status::unknown(
1600                        format!("Service was not ready: {}", e.into()),
1601                    )
1602                })?;
1603            let codec = tonic_prost::ProstCodec::default();
1604            let path = http::uri::PathAndQuery::from_static(
1605                "/ddl_service.DdlService/DropSubscription",
1606            );
1607            let mut req = request.into_request();
1608            req.extensions_mut()
1609                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSubscription"));
1610            self.inner.unary(req, path, codec).await
1611        }
1612        pub async fn create_materialized_view(
1613            &mut self,
1614            request: impl tonic::IntoRequest<super::CreateMaterializedViewRequest>,
1615        ) -> std::result::Result<
1616            tonic::Response<super::CreateMaterializedViewResponse>,
1617            tonic::Status,
1618        > {
1619            self.inner
1620                .ready()
1621                .await
1622                .map_err(|e| {
1623                    tonic::Status::unknown(
1624                        format!("Service was not ready: {}", e.into()),
1625                    )
1626                })?;
1627            let codec = tonic_prost::ProstCodec::default();
1628            let path = http::uri::PathAndQuery::from_static(
1629                "/ddl_service.DdlService/CreateMaterializedView",
1630            );
1631            let mut req = request.into_request();
1632            req.extensions_mut()
1633                .insert(
1634                    GrpcMethod::new("ddl_service.DdlService", "CreateMaterializedView"),
1635                );
1636            self.inner.unary(req, path, codec).await
1637        }
1638        pub async fn drop_materialized_view(
1639            &mut self,
1640            request: impl tonic::IntoRequest<super::DropMaterializedViewRequest>,
1641        ) -> std::result::Result<
1642            tonic::Response<super::DropMaterializedViewResponse>,
1643            tonic::Status,
1644        > {
1645            self.inner
1646                .ready()
1647                .await
1648                .map_err(|e| {
1649                    tonic::Status::unknown(
1650                        format!("Service was not ready: {}", e.into()),
1651                    )
1652                })?;
1653            let codec = tonic_prost::ProstCodec::default();
1654            let path = http::uri::PathAndQuery::from_static(
1655                "/ddl_service.DdlService/DropMaterializedView",
1656            );
1657            let mut req = request.into_request();
1658            req.extensions_mut()
1659                .insert(
1660                    GrpcMethod::new("ddl_service.DdlService", "DropMaterializedView"),
1661                );
1662            self.inner.unary(req, path, codec).await
1663        }
1664        pub async fn create_table(
1665            &mut self,
1666            request: impl tonic::IntoRequest<super::CreateTableRequest>,
1667        ) -> std::result::Result<
1668            tonic::Response<super::CreateTableResponse>,
1669            tonic::Status,
1670        > {
1671            self.inner
1672                .ready()
1673                .await
1674                .map_err(|e| {
1675                    tonic::Status::unknown(
1676                        format!("Service was not ready: {}", e.into()),
1677                    )
1678                })?;
1679            let codec = tonic_prost::ProstCodec::default();
1680            let path = http::uri::PathAndQuery::from_static(
1681                "/ddl_service.DdlService/CreateTable",
1682            );
1683            let mut req = request.into_request();
1684            req.extensions_mut()
1685                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateTable"));
1686            self.inner.unary(req, path, codec).await
1687        }
1688        pub async fn create_iceberg_table(
1689            &mut self,
1690            request: impl tonic::IntoRequest<super::CreateIcebergTableRequest>,
1691        ) -> std::result::Result<
1692            tonic::Response<super::CreateIcebergTableResponse>,
1693            tonic::Status,
1694        > {
1695            self.inner
1696                .ready()
1697                .await
1698                .map_err(|e| {
1699                    tonic::Status::unknown(
1700                        format!("Service was not ready: {}", e.into()),
1701                    )
1702                })?;
1703            let codec = tonic_prost::ProstCodec::default();
1704            let path = http::uri::PathAndQuery::from_static(
1705                "/ddl_service.DdlService/CreateIcebergTable",
1706            );
1707            let mut req = request.into_request();
1708            req.extensions_mut()
1709                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateIcebergTable"));
1710            self.inner.unary(req, path, codec).await
1711        }
1712        pub async fn create_secret(
1713            &mut self,
1714            request: impl tonic::IntoRequest<super::CreateSecretRequest>,
1715        ) -> std::result::Result<
1716            tonic::Response<super::CreateSecretResponse>,
1717            tonic::Status,
1718        > {
1719            self.inner
1720                .ready()
1721                .await
1722                .map_err(|e| {
1723                    tonic::Status::unknown(
1724                        format!("Service was not ready: {}", e.into()),
1725                    )
1726                })?;
1727            let codec = tonic_prost::ProstCodec::default();
1728            let path = http::uri::PathAndQuery::from_static(
1729                "/ddl_service.DdlService/CreateSecret",
1730            );
1731            let mut req = request.into_request();
1732            req.extensions_mut()
1733                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateSecret"));
1734            self.inner.unary(req, path, codec).await
1735        }
1736        pub async fn drop_secret(
1737            &mut self,
1738            request: impl tonic::IntoRequest<super::DropSecretRequest>,
1739        ) -> std::result::Result<
1740            tonic::Response<super::DropSecretResponse>,
1741            tonic::Status,
1742        > {
1743            self.inner
1744                .ready()
1745                .await
1746                .map_err(|e| {
1747                    tonic::Status::unknown(
1748                        format!("Service was not ready: {}", e.into()),
1749                    )
1750                })?;
1751            let codec = tonic_prost::ProstCodec::default();
1752            let path = http::uri::PathAndQuery::from_static(
1753                "/ddl_service.DdlService/DropSecret",
1754            );
1755            let mut req = request.into_request();
1756            req.extensions_mut()
1757                .insert(GrpcMethod::new("ddl_service.DdlService", "DropSecret"));
1758            self.inner.unary(req, path, codec).await
1759        }
1760        pub async fn alter_secret(
1761            &mut self,
1762            request: impl tonic::IntoRequest<super::AlterSecretRequest>,
1763        ) -> std::result::Result<
1764            tonic::Response<super::AlterSecretResponse>,
1765            tonic::Status,
1766        > {
1767            self.inner
1768                .ready()
1769                .await
1770                .map_err(|e| {
1771                    tonic::Status::unknown(
1772                        format!("Service was not ready: {}", e.into()),
1773                    )
1774                })?;
1775            let codec = tonic_prost::ProstCodec::default();
1776            let path = http::uri::PathAndQuery::from_static(
1777                "/ddl_service.DdlService/AlterSecret",
1778            );
1779            let mut req = request.into_request();
1780            req.extensions_mut()
1781                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSecret"));
1782            self.inner.unary(req, path, codec).await
1783        }
1784        pub async fn alter_name(
1785            &mut self,
1786            request: impl tonic::IntoRequest<super::AlterNameRequest>,
1787        ) -> std::result::Result<
1788            tonic::Response<super::AlterNameResponse>,
1789            tonic::Status,
1790        > {
1791            self.inner
1792                .ready()
1793                .await
1794                .map_err(|e| {
1795                    tonic::Status::unknown(
1796                        format!("Service was not ready: {}", e.into()),
1797                    )
1798                })?;
1799            let codec = tonic_prost::ProstCodec::default();
1800            let path = http::uri::PathAndQuery::from_static(
1801                "/ddl_service.DdlService/AlterName",
1802            );
1803            let mut req = request.into_request();
1804            req.extensions_mut()
1805                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterName"));
1806            self.inner.unary(req, path, codec).await
1807        }
1808        pub async fn alter_source(
1809            &mut self,
1810            request: impl tonic::IntoRequest<super::AlterSourceRequest>,
1811        ) -> std::result::Result<
1812            tonic::Response<super::AlterSourceResponse>,
1813            tonic::Status,
1814        > {
1815            self.inner
1816                .ready()
1817                .await
1818                .map_err(|e| {
1819                    tonic::Status::unknown(
1820                        format!("Service was not ready: {}", e.into()),
1821                    )
1822                })?;
1823            let codec = tonic_prost::ProstCodec::default();
1824            let path = http::uri::PathAndQuery::from_static(
1825                "/ddl_service.DdlService/AlterSource",
1826            );
1827            let mut req = request.into_request();
1828            req.extensions_mut()
1829                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSource"));
1830            self.inner.unary(req, path, codec).await
1831        }
1832        pub async fn reset_source(
1833            &mut self,
1834            request: impl tonic::IntoRequest<super::ResetSourceRequest>,
1835        ) -> std::result::Result<
1836            tonic::Response<super::ResetSourceResponse>,
1837            tonic::Status,
1838        > {
1839            self.inner
1840                .ready()
1841                .await
1842                .map_err(|e| {
1843                    tonic::Status::unknown(
1844                        format!("Service was not ready: {}", e.into()),
1845                    )
1846                })?;
1847            let codec = tonic_prost::ProstCodec::default();
1848            let path = http::uri::PathAndQuery::from_static(
1849                "/ddl_service.DdlService/ResetSource",
1850            );
1851            let mut req = request.into_request();
1852            req.extensions_mut()
1853                .insert(GrpcMethod::new("ddl_service.DdlService", "ResetSource"));
1854            self.inner.unary(req, path, codec).await
1855        }
1856        pub async fn alter_owner(
1857            &mut self,
1858            request: impl tonic::IntoRequest<super::AlterOwnerRequest>,
1859        ) -> std::result::Result<
1860            tonic::Response<super::AlterOwnerResponse>,
1861            tonic::Status,
1862        > {
1863            self.inner
1864                .ready()
1865                .await
1866                .map_err(|e| {
1867                    tonic::Status::unknown(
1868                        format!("Service was not ready: {}", e.into()),
1869                    )
1870                })?;
1871            let codec = tonic_prost::ProstCodec::default();
1872            let path = http::uri::PathAndQuery::from_static(
1873                "/ddl_service.DdlService/AlterOwner",
1874            );
1875            let mut req = request.into_request();
1876            req.extensions_mut()
1877                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterOwner"));
1878            self.inner.unary(req, path, codec).await
1879        }
1880        pub async fn alter_subscription_retention(
1881            &mut self,
1882            request: impl tonic::IntoRequest<super::AlterSubscriptionRetentionRequest>,
1883        ) -> std::result::Result<
1884            tonic::Response<super::AlterSubscriptionRetentionResponse>,
1885            tonic::Status,
1886        > {
1887            self.inner
1888                .ready()
1889                .await
1890                .map_err(|e| {
1891                    tonic::Status::unknown(
1892                        format!("Service was not ready: {}", e.into()),
1893                    )
1894                })?;
1895            let codec = tonic_prost::ProstCodec::default();
1896            let path = http::uri::PathAndQuery::from_static(
1897                "/ddl_service.DdlService/AlterSubscriptionRetention",
1898            );
1899            let mut req = request.into_request();
1900            req.extensions_mut()
1901                .insert(
1902                    GrpcMethod::new(
1903                        "ddl_service.DdlService",
1904                        "AlterSubscriptionRetention",
1905                    ),
1906                );
1907            self.inner.unary(req, path, codec).await
1908        }
1909        pub async fn alter_set_schema(
1910            &mut self,
1911            request: impl tonic::IntoRequest<super::AlterSetSchemaRequest>,
1912        ) -> std::result::Result<
1913            tonic::Response<super::AlterSetSchemaResponse>,
1914            tonic::Status,
1915        > {
1916            self.inner
1917                .ready()
1918                .await
1919                .map_err(|e| {
1920                    tonic::Status::unknown(
1921                        format!("Service was not ready: {}", e.into()),
1922                    )
1923                })?;
1924            let codec = tonic_prost::ProstCodec::default();
1925            let path = http::uri::PathAndQuery::from_static(
1926                "/ddl_service.DdlService/AlterSetSchema",
1927            );
1928            let mut req = request.into_request();
1929            req.extensions_mut()
1930                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSetSchema"));
1931            self.inner.unary(req, path, codec).await
1932        }
1933        pub async fn alter_parallelism(
1934            &mut self,
1935            request: impl tonic::IntoRequest<super::AlterParallelismRequest>,
1936        ) -> std::result::Result<
1937            tonic::Response<super::AlterParallelismResponse>,
1938            tonic::Status,
1939        > {
1940            self.inner
1941                .ready()
1942                .await
1943                .map_err(|e| {
1944                    tonic::Status::unknown(
1945                        format!("Service was not ready: {}", e.into()),
1946                    )
1947                })?;
1948            let codec = tonic_prost::ProstCodec::default();
1949            let path = http::uri::PathAndQuery::from_static(
1950                "/ddl_service.DdlService/AlterParallelism",
1951            );
1952            let mut req = request.into_request();
1953            req.extensions_mut()
1954                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterParallelism"));
1955            self.inner.unary(req, path, codec).await
1956        }
1957        pub async fn alter_backfill_parallelism(
1958            &mut self,
1959            request: impl tonic::IntoRequest<super::AlterBackfillParallelismRequest>,
1960        ) -> std::result::Result<
1961            tonic::Response<super::AlterBackfillParallelismResponse>,
1962            tonic::Status,
1963        > {
1964            self.inner
1965                .ready()
1966                .await
1967                .map_err(|e| {
1968                    tonic::Status::unknown(
1969                        format!("Service was not ready: {}", e.into()),
1970                    )
1971                })?;
1972            let codec = tonic_prost::ProstCodec::default();
1973            let path = http::uri::PathAndQuery::from_static(
1974                "/ddl_service.DdlService/AlterBackfillParallelism",
1975            );
1976            let mut req = request.into_request();
1977            req.extensions_mut()
1978                .insert(
1979                    GrpcMethod::new("ddl_service.DdlService", "AlterBackfillParallelism"),
1980                );
1981            self.inner.unary(req, path, codec).await
1982        }
1983        pub async fn alter_fragment_parallelism(
1984            &mut self,
1985            request: impl tonic::IntoRequest<super::AlterFragmentParallelismRequest>,
1986        ) -> std::result::Result<
1987            tonic::Response<super::AlterFragmentParallelismResponse>,
1988            tonic::Status,
1989        > {
1990            self.inner
1991                .ready()
1992                .await
1993                .map_err(|e| {
1994                    tonic::Status::unknown(
1995                        format!("Service was not ready: {}", e.into()),
1996                    )
1997                })?;
1998            let codec = tonic_prost::ProstCodec::default();
1999            let path = http::uri::PathAndQuery::from_static(
2000                "/ddl_service.DdlService/AlterFragmentParallelism",
2001            );
2002            let mut req = request.into_request();
2003            req.extensions_mut()
2004                .insert(
2005                    GrpcMethod::new("ddl_service.DdlService", "AlterFragmentParallelism"),
2006                );
2007            self.inner.unary(req, path, codec).await
2008        }
2009        pub async fn alter_resource_group(
2010            &mut self,
2011            request: impl tonic::IntoRequest<super::AlterResourceGroupRequest>,
2012        ) -> std::result::Result<
2013            tonic::Response<super::AlterResourceGroupResponse>,
2014            tonic::Status,
2015        > {
2016            self.inner
2017                .ready()
2018                .await
2019                .map_err(|e| {
2020                    tonic::Status::unknown(
2021                        format!("Service was not ready: {}", e.into()),
2022                    )
2023                })?;
2024            let codec = tonic_prost::ProstCodec::default();
2025            let path = http::uri::PathAndQuery::from_static(
2026                "/ddl_service.DdlService/AlterResourceGroup",
2027            );
2028            let mut req = request.into_request();
2029            req.extensions_mut()
2030                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterResourceGroup"));
2031            self.inner.unary(req, path, codec).await
2032        }
2033        pub async fn alter_database_resource_group(
2034            &mut self,
2035            request: impl tonic::IntoRequest<super::AlterDatabaseResourceGroupRequest>,
2036        ) -> std::result::Result<
2037            tonic::Response<super::AlterDatabaseResourceGroupResponse>,
2038            tonic::Status,
2039        > {
2040            self.inner
2041                .ready()
2042                .await
2043                .map_err(|e| {
2044                    tonic::Status::unknown(
2045                        format!("Service was not ready: {}", e.into()),
2046                    )
2047                })?;
2048            let codec = tonic_prost::ProstCodec::default();
2049            let path = http::uri::PathAndQuery::from_static(
2050                "/ddl_service.DdlService/AlterDatabaseResourceGroup",
2051            );
2052            let mut req = request.into_request();
2053            req.extensions_mut()
2054                .insert(
2055                    GrpcMethod::new(
2056                        "ddl_service.DdlService",
2057                        "AlterDatabaseResourceGroup",
2058                    ),
2059                );
2060            self.inner.unary(req, path, codec).await
2061        }
2062        pub async fn drop_table(
2063            &mut self,
2064            request: impl tonic::IntoRequest<super::DropTableRequest>,
2065        ) -> std::result::Result<
2066            tonic::Response<super::DropTableResponse>,
2067            tonic::Status,
2068        > {
2069            self.inner
2070                .ready()
2071                .await
2072                .map_err(|e| {
2073                    tonic::Status::unknown(
2074                        format!("Service was not ready: {}", e.into()),
2075                    )
2076                })?;
2077            let codec = tonic_prost::ProstCodec::default();
2078            let path = http::uri::PathAndQuery::from_static(
2079                "/ddl_service.DdlService/DropTable",
2080            );
2081            let mut req = request.into_request();
2082            req.extensions_mut()
2083                .insert(GrpcMethod::new("ddl_service.DdlService", "DropTable"));
2084            self.inner.unary(req, path, codec).await
2085        }
2086        pub async fn risectl_list_state_tables(
2087            &mut self,
2088            request: impl tonic::IntoRequest<super::RisectlListStateTablesRequest>,
2089        ) -> std::result::Result<
2090            tonic::Response<super::RisectlListStateTablesResponse>,
2091            tonic::Status,
2092        > {
2093            self.inner
2094                .ready()
2095                .await
2096                .map_err(|e| {
2097                    tonic::Status::unknown(
2098                        format!("Service was not ready: {}", e.into()),
2099                    )
2100                })?;
2101            let codec = tonic_prost::ProstCodec::default();
2102            let path = http::uri::PathAndQuery::from_static(
2103                "/ddl_service.DdlService/RisectlListStateTables",
2104            );
2105            let mut req = request.into_request();
2106            req.extensions_mut()
2107                .insert(
2108                    GrpcMethod::new("ddl_service.DdlService", "RisectlListStateTables"),
2109                );
2110            self.inner.unary(req, path, codec).await
2111        }
2112        pub async fn risectl_resume_backfill(
2113            &mut self,
2114            request: impl tonic::IntoRequest<super::RisectlResumeBackfillRequest>,
2115        ) -> std::result::Result<
2116            tonic::Response<super::RisectlResumeBackfillResponse>,
2117            tonic::Status,
2118        > {
2119            self.inner
2120                .ready()
2121                .await
2122                .map_err(|e| {
2123                    tonic::Status::unknown(
2124                        format!("Service was not ready: {}", e.into()),
2125                    )
2126                })?;
2127            let codec = tonic_prost::ProstCodec::default();
2128            let path = http::uri::PathAndQuery::from_static(
2129                "/ddl_service.DdlService/RisectlResumeBackfill",
2130            );
2131            let mut req = request.into_request();
2132            req.extensions_mut()
2133                .insert(
2134                    GrpcMethod::new("ddl_service.DdlService", "RisectlResumeBackfill"),
2135                );
2136            self.inner.unary(req, path, codec).await
2137        }
2138        pub async fn create_view(
2139            &mut self,
2140            request: impl tonic::IntoRequest<super::CreateViewRequest>,
2141        ) -> std::result::Result<
2142            tonic::Response<super::CreateViewResponse>,
2143            tonic::Status,
2144        > {
2145            self.inner
2146                .ready()
2147                .await
2148                .map_err(|e| {
2149                    tonic::Status::unknown(
2150                        format!("Service was not ready: {}", e.into()),
2151                    )
2152                })?;
2153            let codec = tonic_prost::ProstCodec::default();
2154            let path = http::uri::PathAndQuery::from_static(
2155                "/ddl_service.DdlService/CreateView",
2156            );
2157            let mut req = request.into_request();
2158            req.extensions_mut()
2159                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateView"));
2160            self.inner.unary(req, path, codec).await
2161        }
2162        pub async fn drop_view(
2163            &mut self,
2164            request: impl tonic::IntoRequest<super::DropViewRequest>,
2165        ) -> std::result::Result<
2166            tonic::Response<super::DropViewResponse>,
2167            tonic::Status,
2168        > {
2169            self.inner
2170                .ready()
2171                .await
2172                .map_err(|e| {
2173                    tonic::Status::unknown(
2174                        format!("Service was not ready: {}", e.into()),
2175                    )
2176                })?;
2177            let codec = tonic_prost::ProstCodec::default();
2178            let path = http::uri::PathAndQuery::from_static(
2179                "/ddl_service.DdlService/DropView",
2180            );
2181            let mut req = request.into_request();
2182            req.extensions_mut()
2183                .insert(GrpcMethod::new("ddl_service.DdlService", "DropView"));
2184            self.inner.unary(req, path, codec).await
2185        }
2186        pub async fn create_index(
2187            &mut self,
2188            request: impl tonic::IntoRequest<super::CreateIndexRequest>,
2189        ) -> std::result::Result<
2190            tonic::Response<super::CreateIndexResponse>,
2191            tonic::Status,
2192        > {
2193            self.inner
2194                .ready()
2195                .await
2196                .map_err(|e| {
2197                    tonic::Status::unknown(
2198                        format!("Service was not ready: {}", e.into()),
2199                    )
2200                })?;
2201            let codec = tonic_prost::ProstCodec::default();
2202            let path = http::uri::PathAndQuery::from_static(
2203                "/ddl_service.DdlService/CreateIndex",
2204            );
2205            let mut req = request.into_request();
2206            req.extensions_mut()
2207                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateIndex"));
2208            self.inner.unary(req, path, codec).await
2209        }
2210        pub async fn drop_index(
2211            &mut self,
2212            request: impl tonic::IntoRequest<super::DropIndexRequest>,
2213        ) -> std::result::Result<
2214            tonic::Response<super::DropIndexResponse>,
2215            tonic::Status,
2216        > {
2217            self.inner
2218                .ready()
2219                .await
2220                .map_err(|e| {
2221                    tonic::Status::unknown(
2222                        format!("Service was not ready: {}", e.into()),
2223                    )
2224                })?;
2225            let codec = tonic_prost::ProstCodec::default();
2226            let path = http::uri::PathAndQuery::from_static(
2227                "/ddl_service.DdlService/DropIndex",
2228            );
2229            let mut req = request.into_request();
2230            req.extensions_mut()
2231                .insert(GrpcMethod::new("ddl_service.DdlService", "DropIndex"));
2232            self.inner.unary(req, path, codec).await
2233        }
2234        pub async fn create_function(
2235            &mut self,
2236            request: impl tonic::IntoRequest<super::CreateFunctionRequest>,
2237        ) -> std::result::Result<
2238            tonic::Response<super::CreateFunctionResponse>,
2239            tonic::Status,
2240        > {
2241            self.inner
2242                .ready()
2243                .await
2244                .map_err(|e| {
2245                    tonic::Status::unknown(
2246                        format!("Service was not ready: {}", e.into()),
2247                    )
2248                })?;
2249            let codec = tonic_prost::ProstCodec::default();
2250            let path = http::uri::PathAndQuery::from_static(
2251                "/ddl_service.DdlService/CreateFunction",
2252            );
2253            let mut req = request.into_request();
2254            req.extensions_mut()
2255                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateFunction"));
2256            self.inner.unary(req, path, codec).await
2257        }
2258        pub async fn drop_function(
2259            &mut self,
2260            request: impl tonic::IntoRequest<super::DropFunctionRequest>,
2261        ) -> std::result::Result<
2262            tonic::Response<super::DropFunctionResponse>,
2263            tonic::Status,
2264        > {
2265            self.inner
2266                .ready()
2267                .await
2268                .map_err(|e| {
2269                    tonic::Status::unknown(
2270                        format!("Service was not ready: {}", e.into()),
2271                    )
2272                })?;
2273            let codec = tonic_prost::ProstCodec::default();
2274            let path = http::uri::PathAndQuery::from_static(
2275                "/ddl_service.DdlService/DropFunction",
2276            );
2277            let mut req = request.into_request();
2278            req.extensions_mut()
2279                .insert(GrpcMethod::new("ddl_service.DdlService", "DropFunction"));
2280            self.inner.unary(req, path, codec).await
2281        }
2282        pub async fn replace_job_plan(
2283            &mut self,
2284            request: impl tonic::IntoRequest<super::ReplaceJobPlanRequest>,
2285        ) -> std::result::Result<
2286            tonic::Response<super::ReplaceJobPlanResponse>,
2287            tonic::Status,
2288        > {
2289            self.inner
2290                .ready()
2291                .await
2292                .map_err(|e| {
2293                    tonic::Status::unknown(
2294                        format!("Service was not ready: {}", e.into()),
2295                    )
2296                })?;
2297            let codec = tonic_prost::ProstCodec::default();
2298            let path = http::uri::PathAndQuery::from_static(
2299                "/ddl_service.DdlService/ReplaceJobPlan",
2300            );
2301            let mut req = request.into_request();
2302            req.extensions_mut()
2303                .insert(GrpcMethod::new("ddl_service.DdlService", "ReplaceJobPlan"));
2304            self.inner.unary(req, path, codec).await
2305        }
2306        pub async fn get_table(
2307            &mut self,
2308            request: impl tonic::IntoRequest<super::GetTableRequest>,
2309        ) -> std::result::Result<
2310            tonic::Response<super::GetTableResponse>,
2311            tonic::Status,
2312        > {
2313            self.inner
2314                .ready()
2315                .await
2316                .map_err(|e| {
2317                    tonic::Status::unknown(
2318                        format!("Service was not ready: {}", e.into()),
2319                    )
2320                })?;
2321            let codec = tonic_prost::ProstCodec::default();
2322            let path = http::uri::PathAndQuery::from_static(
2323                "/ddl_service.DdlService/GetTable",
2324            );
2325            let mut req = request.into_request();
2326            req.extensions_mut()
2327                .insert(GrpcMethod::new("ddl_service.DdlService", "GetTable"));
2328            self.inner.unary(req, path, codec).await
2329        }
2330        pub async fn get_ddl_progress(
2331            &mut self,
2332            request: impl tonic::IntoRequest<super::GetDdlProgressRequest>,
2333        ) -> std::result::Result<
2334            tonic::Response<super::GetDdlProgressResponse>,
2335            tonic::Status,
2336        > {
2337            self.inner
2338                .ready()
2339                .await
2340                .map_err(|e| {
2341                    tonic::Status::unknown(
2342                        format!("Service was not ready: {}", e.into()),
2343                    )
2344                })?;
2345            let codec = tonic_prost::ProstCodec::default();
2346            let path = http::uri::PathAndQuery::from_static(
2347                "/ddl_service.DdlService/GetDdlProgress",
2348            );
2349            let mut req = request.into_request();
2350            req.extensions_mut()
2351                .insert(GrpcMethod::new("ddl_service.DdlService", "GetDdlProgress"));
2352            self.inner.unary(req, path, codec).await
2353        }
2354        pub async fn create_connection(
2355            &mut self,
2356            request: impl tonic::IntoRequest<super::CreateConnectionRequest>,
2357        ) -> std::result::Result<
2358            tonic::Response<super::CreateConnectionResponse>,
2359            tonic::Status,
2360        > {
2361            self.inner
2362                .ready()
2363                .await
2364                .map_err(|e| {
2365                    tonic::Status::unknown(
2366                        format!("Service was not ready: {}", e.into()),
2367                    )
2368                })?;
2369            let codec = tonic_prost::ProstCodec::default();
2370            let path = http::uri::PathAndQuery::from_static(
2371                "/ddl_service.DdlService/CreateConnection",
2372            );
2373            let mut req = request.into_request();
2374            req.extensions_mut()
2375                .insert(GrpcMethod::new("ddl_service.DdlService", "CreateConnection"));
2376            self.inner.unary(req, path, codec).await
2377        }
2378        pub async fn list_connections(
2379            &mut self,
2380            request: impl tonic::IntoRequest<super::ListConnectionsRequest>,
2381        ) -> std::result::Result<
2382            tonic::Response<super::ListConnectionsResponse>,
2383            tonic::Status,
2384        > {
2385            self.inner
2386                .ready()
2387                .await
2388                .map_err(|e| {
2389                    tonic::Status::unknown(
2390                        format!("Service was not ready: {}", e.into()),
2391                    )
2392                })?;
2393            let codec = tonic_prost::ProstCodec::default();
2394            let path = http::uri::PathAndQuery::from_static(
2395                "/ddl_service.DdlService/ListConnections",
2396            );
2397            let mut req = request.into_request();
2398            req.extensions_mut()
2399                .insert(GrpcMethod::new("ddl_service.DdlService", "ListConnections"));
2400            self.inner.unary(req, path, codec).await
2401        }
2402        pub async fn drop_connection(
2403            &mut self,
2404            request: impl tonic::IntoRequest<super::DropConnectionRequest>,
2405        ) -> std::result::Result<
2406            tonic::Response<super::DropConnectionResponse>,
2407            tonic::Status,
2408        > {
2409            self.inner
2410                .ready()
2411                .await
2412                .map_err(|e| {
2413                    tonic::Status::unknown(
2414                        format!("Service was not ready: {}", e.into()),
2415                    )
2416                })?;
2417            let codec = tonic_prost::ProstCodec::default();
2418            let path = http::uri::PathAndQuery::from_static(
2419                "/ddl_service.DdlService/DropConnection",
2420            );
2421            let mut req = request.into_request();
2422            req.extensions_mut()
2423                .insert(GrpcMethod::new("ddl_service.DdlService", "DropConnection"));
2424            self.inner.unary(req, path, codec).await
2425        }
2426        pub async fn get_tables(
2427            &mut self,
2428            request: impl tonic::IntoRequest<super::GetTablesRequest>,
2429        ) -> std::result::Result<
2430            tonic::Response<super::GetTablesResponse>,
2431            tonic::Status,
2432        > {
2433            self.inner
2434                .ready()
2435                .await
2436                .map_err(|e| {
2437                    tonic::Status::unknown(
2438                        format!("Service was not ready: {}", e.into()),
2439                    )
2440                })?;
2441            let codec = tonic_prost::ProstCodec::default();
2442            let path = http::uri::PathAndQuery::from_static(
2443                "/ddl_service.DdlService/GetTables",
2444            );
2445            let mut req = request.into_request();
2446            req.extensions_mut()
2447                .insert(GrpcMethod::new("ddl_service.DdlService", "GetTables"));
2448            self.inner.unary(req, path, codec).await
2449        }
2450        pub async fn wait(
2451            &mut self,
2452            request: impl tonic::IntoRequest<super::WaitRequest>,
2453        ) -> std::result::Result<tonic::Response<super::WaitResponse>, tonic::Status> {
2454            self.inner
2455                .ready()
2456                .await
2457                .map_err(|e| {
2458                    tonic::Status::unknown(
2459                        format!("Service was not ready: {}", e.into()),
2460                    )
2461                })?;
2462            let codec = tonic_prost::ProstCodec::default();
2463            let path = http::uri::PathAndQuery::from_static(
2464                "/ddl_service.DdlService/Wait",
2465            );
2466            let mut req = request.into_request();
2467            req.extensions_mut()
2468                .insert(GrpcMethod::new("ddl_service.DdlService", "Wait"));
2469            self.inner.unary(req, path, codec).await
2470        }
2471        pub async fn comment_on(
2472            &mut self,
2473            request: impl tonic::IntoRequest<super::CommentOnRequest>,
2474        ) -> std::result::Result<
2475            tonic::Response<super::CommentOnResponse>,
2476            tonic::Status,
2477        > {
2478            self.inner
2479                .ready()
2480                .await
2481                .map_err(|e| {
2482                    tonic::Status::unknown(
2483                        format!("Service was not ready: {}", e.into()),
2484                    )
2485                })?;
2486            let codec = tonic_prost::ProstCodec::default();
2487            let path = http::uri::PathAndQuery::from_static(
2488                "/ddl_service.DdlService/CommentOn",
2489            );
2490            let mut req = request.into_request();
2491            req.extensions_mut()
2492                .insert(GrpcMethod::new("ddl_service.DdlService", "CommentOn"));
2493            self.inner.unary(req, path, codec).await
2494        }
2495        pub async fn auto_schema_change(
2496            &mut self,
2497            request: impl tonic::IntoRequest<super::AutoSchemaChangeRequest>,
2498        ) -> std::result::Result<
2499            tonic::Response<super::AutoSchemaChangeResponse>,
2500            tonic::Status,
2501        > {
2502            self.inner
2503                .ready()
2504                .await
2505                .map_err(|e| {
2506                    tonic::Status::unknown(
2507                        format!("Service was not ready: {}", e.into()),
2508                    )
2509                })?;
2510            let codec = tonic_prost::ProstCodec::default();
2511            let path = http::uri::PathAndQuery::from_static(
2512                "/ddl_service.DdlService/AutoSchemaChange",
2513            );
2514            let mut req = request.into_request();
2515            req.extensions_mut()
2516                .insert(GrpcMethod::new("ddl_service.DdlService", "AutoSchemaChange"));
2517            self.inner.unary(req, path, codec).await
2518        }
2519        pub async fn alter_swap_rename(
2520            &mut self,
2521            request: impl tonic::IntoRequest<super::AlterSwapRenameRequest>,
2522        ) -> std::result::Result<
2523            tonic::Response<super::AlterSwapRenameResponse>,
2524            tonic::Status,
2525        > {
2526            self.inner
2527                .ready()
2528                .await
2529                .map_err(|e| {
2530                    tonic::Status::unknown(
2531                        format!("Service was not ready: {}", e.into()),
2532                    )
2533                })?;
2534            let codec = tonic_prost::ProstCodec::default();
2535            let path = http::uri::PathAndQuery::from_static(
2536                "/ddl_service.DdlService/AlterSwapRename",
2537            );
2538            let mut req = request.into_request();
2539            req.extensions_mut()
2540                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterSwapRename"));
2541            self.inner.unary(req, path, codec).await
2542        }
2543        pub async fn alter_database_param(
2544            &mut self,
2545            request: impl tonic::IntoRequest<super::AlterDatabaseParamRequest>,
2546        ) -> std::result::Result<
2547            tonic::Response<super::AlterDatabaseParamResponse>,
2548            tonic::Status,
2549        > {
2550            self.inner
2551                .ready()
2552                .await
2553                .map_err(|e| {
2554                    tonic::Status::unknown(
2555                        format!("Service was not ready: {}", e.into()),
2556                    )
2557                })?;
2558            let codec = tonic_prost::ProstCodec::default();
2559            let path = http::uri::PathAndQuery::from_static(
2560                "/ddl_service.DdlService/AlterDatabaseParam",
2561            );
2562            let mut req = request.into_request();
2563            req.extensions_mut()
2564                .insert(GrpcMethod::new("ddl_service.DdlService", "AlterDatabaseParam"));
2565            self.inner.unary(req, path, codec).await
2566        }
2567        pub async fn compact_iceberg_table(
2568            &mut self,
2569            request: impl tonic::IntoRequest<super::CompactIcebergTableRequest>,
2570        ) -> std::result::Result<
2571            tonic::Response<super::CompactIcebergTableResponse>,
2572            tonic::Status,
2573        > {
2574            self.inner
2575                .ready()
2576                .await
2577                .map_err(|e| {
2578                    tonic::Status::unknown(
2579                        format!("Service was not ready: {}", e.into()),
2580                    )
2581                })?;
2582            let codec = tonic_prost::ProstCodec::default();
2583            let path = http::uri::PathAndQuery::from_static(
2584                "/ddl_service.DdlService/CompactIcebergTable",
2585            );
2586            let mut req = request.into_request();
2587            req.extensions_mut()
2588                .insert(
2589                    GrpcMethod::new("ddl_service.DdlService", "CompactIcebergTable"),
2590                );
2591            self.inner.unary(req, path, codec).await
2592        }
2593        pub async fn expire_iceberg_table_snapshots(
2594            &mut self,
2595            request: impl tonic::IntoRequest<super::ExpireIcebergTableSnapshotsRequest>,
2596        ) -> std::result::Result<
2597            tonic::Response<super::ExpireIcebergTableSnapshotsResponse>,
2598            tonic::Status,
2599        > {
2600            self.inner
2601                .ready()
2602                .await
2603                .map_err(|e| {
2604                    tonic::Status::unknown(
2605                        format!("Service was not ready: {}", e.into()),
2606                    )
2607                })?;
2608            let codec = tonic_prost::ProstCodec::default();
2609            let path = http::uri::PathAndQuery::from_static(
2610                "/ddl_service.DdlService/ExpireIcebergTableSnapshots",
2611            );
2612            let mut req = request.into_request();
2613            req.extensions_mut()
2614                .insert(
2615                    GrpcMethod::new(
2616                        "ddl_service.DdlService",
2617                        "ExpireIcebergTableSnapshots",
2618                    ),
2619                );
2620            self.inner.unary(req, path, codec).await
2621        }
2622        pub async fn alter_cdc_table_backfill_parallelism(
2623            &mut self,
2624            request: impl tonic::IntoRequest<
2625                super::AlterCdcTableBackfillParallelismRequest,
2626            >,
2627        ) -> std::result::Result<
2628            tonic::Response<super::AlterCdcTableBackfillParallelismResponse>,
2629            tonic::Status,
2630        > {
2631            self.inner
2632                .ready()
2633                .await
2634                .map_err(|e| {
2635                    tonic::Status::unknown(
2636                        format!("Service was not ready: {}", e.into()),
2637                    )
2638                })?;
2639            let codec = tonic_prost::ProstCodec::default();
2640            let path = http::uri::PathAndQuery::from_static(
2641                "/ddl_service.DdlService/AlterCdcTableBackfillParallelism",
2642            );
2643            let mut req = request.into_request();
2644            req.extensions_mut()
2645                .insert(
2646                    GrpcMethod::new(
2647                        "ddl_service.DdlService",
2648                        "AlterCdcTableBackfillParallelism",
2649                    ),
2650                );
2651            self.inner.unary(req, path, codec).await
2652        }
2653        pub async fn alter_streaming_job_config(
2654            &mut self,
2655            request: impl tonic::IntoRequest<super::AlterStreamingJobConfigRequest>,
2656        ) -> std::result::Result<
2657            tonic::Response<super::AlterStreamingJobConfigResponse>,
2658            tonic::Status,
2659        > {
2660            self.inner
2661                .ready()
2662                .await
2663                .map_err(|e| {
2664                    tonic::Status::unknown(
2665                        format!("Service was not ready: {}", e.into()),
2666                    )
2667                })?;
2668            let codec = tonic_prost::ProstCodec::default();
2669            let path = http::uri::PathAndQuery::from_static(
2670                "/ddl_service.DdlService/AlterStreamingJobConfig",
2671            );
2672            let mut req = request.into_request();
2673            req.extensions_mut()
2674                .insert(
2675                    GrpcMethod::new("ddl_service.DdlService", "AlterStreamingJobConfig"),
2676                );
2677            self.inner.unary(req, path, codec).await
2678        }
2679    }
2680}
2681/// Generated server implementations.
2682pub mod ddl_service_server {
2683    #![allow(
2684        unused_variables,
2685        dead_code,
2686        missing_docs,
2687        clippy::wildcard_imports,
2688        clippy::let_unit_value,
2689    )]
2690    use tonic::codegen::*;
2691    /// Generated trait containing gRPC methods that should be implemented for use with DdlServiceServer.
2692    #[async_trait]
2693    pub trait DdlService: std::marker::Send + std::marker::Sync + 'static {
2694        async fn create_database(
2695            &self,
2696            request: tonic::Request<super::CreateDatabaseRequest>,
2697        ) -> std::result::Result<
2698            tonic::Response<super::CreateDatabaseResponse>,
2699            tonic::Status,
2700        >;
2701        async fn drop_database(
2702            &self,
2703            request: tonic::Request<super::DropDatabaseRequest>,
2704        ) -> std::result::Result<
2705            tonic::Response<super::DropDatabaseResponse>,
2706            tonic::Status,
2707        >;
2708        async fn create_schema(
2709            &self,
2710            request: tonic::Request<super::CreateSchemaRequest>,
2711        ) -> std::result::Result<
2712            tonic::Response<super::CreateSchemaResponse>,
2713            tonic::Status,
2714        >;
2715        async fn drop_schema(
2716            &self,
2717            request: tonic::Request<super::DropSchemaRequest>,
2718        ) -> std::result::Result<
2719            tonic::Response<super::DropSchemaResponse>,
2720            tonic::Status,
2721        >;
2722        async fn create_source(
2723            &self,
2724            request: tonic::Request<super::CreateSourceRequest>,
2725        ) -> std::result::Result<
2726            tonic::Response<super::CreateSourceResponse>,
2727            tonic::Status,
2728        >;
2729        async fn drop_source(
2730            &self,
2731            request: tonic::Request<super::DropSourceRequest>,
2732        ) -> std::result::Result<
2733            tonic::Response<super::DropSourceResponse>,
2734            tonic::Status,
2735        >;
2736        async fn create_sink(
2737            &self,
2738            request: tonic::Request<super::CreateSinkRequest>,
2739        ) -> std::result::Result<
2740            tonic::Response<super::CreateSinkResponse>,
2741            tonic::Status,
2742        >;
2743        async fn create_subscription(
2744            &self,
2745            request: tonic::Request<super::CreateSubscriptionRequest>,
2746        ) -> std::result::Result<
2747            tonic::Response<super::CreateSubscriptionResponse>,
2748            tonic::Status,
2749        >;
2750        async fn drop_sink(
2751            &self,
2752            request: tonic::Request<super::DropSinkRequest>,
2753        ) -> std::result::Result<
2754            tonic::Response<super::DropSinkResponse>,
2755            tonic::Status,
2756        >;
2757        async fn drop_subscription(
2758            &self,
2759            request: tonic::Request<super::DropSubscriptionRequest>,
2760        ) -> std::result::Result<
2761            tonic::Response<super::DropSubscriptionResponse>,
2762            tonic::Status,
2763        >;
2764        async fn create_materialized_view(
2765            &self,
2766            request: tonic::Request<super::CreateMaterializedViewRequest>,
2767        ) -> std::result::Result<
2768            tonic::Response<super::CreateMaterializedViewResponse>,
2769            tonic::Status,
2770        >;
2771        async fn drop_materialized_view(
2772            &self,
2773            request: tonic::Request<super::DropMaterializedViewRequest>,
2774        ) -> std::result::Result<
2775            tonic::Response<super::DropMaterializedViewResponse>,
2776            tonic::Status,
2777        >;
2778        async fn create_table(
2779            &self,
2780            request: tonic::Request<super::CreateTableRequest>,
2781        ) -> std::result::Result<
2782            tonic::Response<super::CreateTableResponse>,
2783            tonic::Status,
2784        >;
2785        async fn create_iceberg_table(
2786            &self,
2787            request: tonic::Request<super::CreateIcebergTableRequest>,
2788        ) -> std::result::Result<
2789            tonic::Response<super::CreateIcebergTableResponse>,
2790            tonic::Status,
2791        >;
2792        async fn create_secret(
2793            &self,
2794            request: tonic::Request<super::CreateSecretRequest>,
2795        ) -> std::result::Result<
2796            tonic::Response<super::CreateSecretResponse>,
2797            tonic::Status,
2798        >;
2799        async fn drop_secret(
2800            &self,
2801            request: tonic::Request<super::DropSecretRequest>,
2802        ) -> std::result::Result<
2803            tonic::Response<super::DropSecretResponse>,
2804            tonic::Status,
2805        >;
2806        async fn alter_secret(
2807            &self,
2808            request: tonic::Request<super::AlterSecretRequest>,
2809        ) -> std::result::Result<
2810            tonic::Response<super::AlterSecretResponse>,
2811            tonic::Status,
2812        >;
2813        async fn alter_name(
2814            &self,
2815            request: tonic::Request<super::AlterNameRequest>,
2816        ) -> std::result::Result<
2817            tonic::Response<super::AlterNameResponse>,
2818            tonic::Status,
2819        >;
2820        async fn alter_source(
2821            &self,
2822            request: tonic::Request<super::AlterSourceRequest>,
2823        ) -> std::result::Result<
2824            tonic::Response<super::AlterSourceResponse>,
2825            tonic::Status,
2826        >;
2827        async fn reset_source(
2828            &self,
2829            request: tonic::Request<super::ResetSourceRequest>,
2830        ) -> std::result::Result<
2831            tonic::Response<super::ResetSourceResponse>,
2832            tonic::Status,
2833        >;
2834        async fn alter_owner(
2835            &self,
2836            request: tonic::Request<super::AlterOwnerRequest>,
2837        ) -> std::result::Result<
2838            tonic::Response<super::AlterOwnerResponse>,
2839            tonic::Status,
2840        >;
2841        async fn alter_subscription_retention(
2842            &self,
2843            request: tonic::Request<super::AlterSubscriptionRetentionRequest>,
2844        ) -> std::result::Result<
2845            tonic::Response<super::AlterSubscriptionRetentionResponse>,
2846            tonic::Status,
2847        >;
2848        async fn alter_set_schema(
2849            &self,
2850            request: tonic::Request<super::AlterSetSchemaRequest>,
2851        ) -> std::result::Result<
2852            tonic::Response<super::AlterSetSchemaResponse>,
2853            tonic::Status,
2854        >;
2855        async fn alter_parallelism(
2856            &self,
2857            request: tonic::Request<super::AlterParallelismRequest>,
2858        ) -> std::result::Result<
2859            tonic::Response<super::AlterParallelismResponse>,
2860            tonic::Status,
2861        >;
2862        async fn alter_backfill_parallelism(
2863            &self,
2864            request: tonic::Request<super::AlterBackfillParallelismRequest>,
2865        ) -> std::result::Result<
2866            tonic::Response<super::AlterBackfillParallelismResponse>,
2867            tonic::Status,
2868        >;
2869        async fn alter_fragment_parallelism(
2870            &self,
2871            request: tonic::Request<super::AlterFragmentParallelismRequest>,
2872        ) -> std::result::Result<
2873            tonic::Response<super::AlterFragmentParallelismResponse>,
2874            tonic::Status,
2875        >;
2876        async fn alter_resource_group(
2877            &self,
2878            request: tonic::Request<super::AlterResourceGroupRequest>,
2879        ) -> std::result::Result<
2880            tonic::Response<super::AlterResourceGroupResponse>,
2881            tonic::Status,
2882        >;
2883        async fn alter_database_resource_group(
2884            &self,
2885            request: tonic::Request<super::AlterDatabaseResourceGroupRequest>,
2886        ) -> std::result::Result<
2887            tonic::Response<super::AlterDatabaseResourceGroupResponse>,
2888            tonic::Status,
2889        >;
2890        async fn drop_table(
2891            &self,
2892            request: tonic::Request<super::DropTableRequest>,
2893        ) -> std::result::Result<
2894            tonic::Response<super::DropTableResponse>,
2895            tonic::Status,
2896        >;
2897        async fn risectl_list_state_tables(
2898            &self,
2899            request: tonic::Request<super::RisectlListStateTablesRequest>,
2900        ) -> std::result::Result<
2901            tonic::Response<super::RisectlListStateTablesResponse>,
2902            tonic::Status,
2903        >;
2904        async fn risectl_resume_backfill(
2905            &self,
2906            request: tonic::Request<super::RisectlResumeBackfillRequest>,
2907        ) -> std::result::Result<
2908            tonic::Response<super::RisectlResumeBackfillResponse>,
2909            tonic::Status,
2910        >;
2911        async fn create_view(
2912            &self,
2913            request: tonic::Request<super::CreateViewRequest>,
2914        ) -> std::result::Result<
2915            tonic::Response<super::CreateViewResponse>,
2916            tonic::Status,
2917        >;
2918        async fn drop_view(
2919            &self,
2920            request: tonic::Request<super::DropViewRequest>,
2921        ) -> std::result::Result<
2922            tonic::Response<super::DropViewResponse>,
2923            tonic::Status,
2924        >;
2925        async fn create_index(
2926            &self,
2927            request: tonic::Request<super::CreateIndexRequest>,
2928        ) -> std::result::Result<
2929            tonic::Response<super::CreateIndexResponse>,
2930            tonic::Status,
2931        >;
2932        async fn drop_index(
2933            &self,
2934            request: tonic::Request<super::DropIndexRequest>,
2935        ) -> std::result::Result<
2936            tonic::Response<super::DropIndexResponse>,
2937            tonic::Status,
2938        >;
2939        async fn create_function(
2940            &self,
2941            request: tonic::Request<super::CreateFunctionRequest>,
2942        ) -> std::result::Result<
2943            tonic::Response<super::CreateFunctionResponse>,
2944            tonic::Status,
2945        >;
2946        async fn drop_function(
2947            &self,
2948            request: tonic::Request<super::DropFunctionRequest>,
2949        ) -> std::result::Result<
2950            tonic::Response<super::DropFunctionResponse>,
2951            tonic::Status,
2952        >;
2953        async fn replace_job_plan(
2954            &self,
2955            request: tonic::Request<super::ReplaceJobPlanRequest>,
2956        ) -> std::result::Result<
2957            tonic::Response<super::ReplaceJobPlanResponse>,
2958            tonic::Status,
2959        >;
2960        async fn get_table(
2961            &self,
2962            request: tonic::Request<super::GetTableRequest>,
2963        ) -> std::result::Result<
2964            tonic::Response<super::GetTableResponse>,
2965            tonic::Status,
2966        >;
2967        async fn get_ddl_progress(
2968            &self,
2969            request: tonic::Request<super::GetDdlProgressRequest>,
2970        ) -> std::result::Result<
2971            tonic::Response<super::GetDdlProgressResponse>,
2972            tonic::Status,
2973        >;
2974        async fn create_connection(
2975            &self,
2976            request: tonic::Request<super::CreateConnectionRequest>,
2977        ) -> std::result::Result<
2978            tonic::Response<super::CreateConnectionResponse>,
2979            tonic::Status,
2980        >;
2981        async fn list_connections(
2982            &self,
2983            request: tonic::Request<super::ListConnectionsRequest>,
2984        ) -> std::result::Result<
2985            tonic::Response<super::ListConnectionsResponse>,
2986            tonic::Status,
2987        >;
2988        async fn drop_connection(
2989            &self,
2990            request: tonic::Request<super::DropConnectionRequest>,
2991        ) -> std::result::Result<
2992            tonic::Response<super::DropConnectionResponse>,
2993            tonic::Status,
2994        >;
2995        async fn get_tables(
2996            &self,
2997            request: tonic::Request<super::GetTablesRequest>,
2998        ) -> std::result::Result<
2999            tonic::Response<super::GetTablesResponse>,
3000            tonic::Status,
3001        >;
3002        async fn wait(
3003            &self,
3004            request: tonic::Request<super::WaitRequest>,
3005        ) -> std::result::Result<tonic::Response<super::WaitResponse>, tonic::Status>;
3006        async fn comment_on(
3007            &self,
3008            request: tonic::Request<super::CommentOnRequest>,
3009        ) -> std::result::Result<
3010            tonic::Response<super::CommentOnResponse>,
3011            tonic::Status,
3012        >;
3013        async fn auto_schema_change(
3014            &self,
3015            request: tonic::Request<super::AutoSchemaChangeRequest>,
3016        ) -> std::result::Result<
3017            tonic::Response<super::AutoSchemaChangeResponse>,
3018            tonic::Status,
3019        >;
3020        async fn alter_swap_rename(
3021            &self,
3022            request: tonic::Request<super::AlterSwapRenameRequest>,
3023        ) -> std::result::Result<
3024            tonic::Response<super::AlterSwapRenameResponse>,
3025            tonic::Status,
3026        >;
3027        async fn alter_database_param(
3028            &self,
3029            request: tonic::Request<super::AlterDatabaseParamRequest>,
3030        ) -> std::result::Result<
3031            tonic::Response<super::AlterDatabaseParamResponse>,
3032            tonic::Status,
3033        >;
3034        async fn compact_iceberg_table(
3035            &self,
3036            request: tonic::Request<super::CompactIcebergTableRequest>,
3037        ) -> std::result::Result<
3038            tonic::Response<super::CompactIcebergTableResponse>,
3039            tonic::Status,
3040        >;
3041        async fn expire_iceberg_table_snapshots(
3042            &self,
3043            request: tonic::Request<super::ExpireIcebergTableSnapshotsRequest>,
3044        ) -> std::result::Result<
3045            tonic::Response<super::ExpireIcebergTableSnapshotsResponse>,
3046            tonic::Status,
3047        >;
3048        async fn alter_cdc_table_backfill_parallelism(
3049            &self,
3050            request: tonic::Request<super::AlterCdcTableBackfillParallelismRequest>,
3051        ) -> std::result::Result<
3052            tonic::Response<super::AlterCdcTableBackfillParallelismResponse>,
3053            tonic::Status,
3054        >;
3055        async fn alter_streaming_job_config(
3056            &self,
3057            request: tonic::Request<super::AlterStreamingJobConfigRequest>,
3058        ) -> std::result::Result<
3059            tonic::Response<super::AlterStreamingJobConfigResponse>,
3060            tonic::Status,
3061        >;
3062    }
3063    #[derive(Debug)]
3064    pub struct DdlServiceServer<T> {
3065        inner: Arc<T>,
3066        accept_compression_encodings: EnabledCompressionEncodings,
3067        send_compression_encodings: EnabledCompressionEncodings,
3068        max_decoding_message_size: Option<usize>,
3069        max_encoding_message_size: Option<usize>,
3070    }
3071    impl<T> DdlServiceServer<T> {
3072        pub fn new(inner: T) -> Self {
3073            Self::from_arc(Arc::new(inner))
3074        }
3075        pub fn from_arc(inner: Arc<T>) -> Self {
3076            Self {
3077                inner,
3078                accept_compression_encodings: Default::default(),
3079                send_compression_encodings: Default::default(),
3080                max_decoding_message_size: None,
3081                max_encoding_message_size: None,
3082            }
3083        }
3084        pub fn with_interceptor<F>(
3085            inner: T,
3086            interceptor: F,
3087        ) -> InterceptedService<Self, F>
3088        where
3089            F: tonic::service::Interceptor,
3090        {
3091            InterceptedService::new(Self::new(inner), interceptor)
3092        }
3093        /// Enable decompressing requests with the given encoding.
3094        #[must_use]
3095        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
3096            self.accept_compression_encodings.enable(encoding);
3097            self
3098        }
3099        /// Compress responses with the given encoding, if the client supports it.
3100        #[must_use]
3101        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
3102            self.send_compression_encodings.enable(encoding);
3103            self
3104        }
3105        /// Limits the maximum size of a decoded message.
3106        ///
3107        /// Default: `4MB`
3108        #[must_use]
3109        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
3110            self.max_decoding_message_size = Some(limit);
3111            self
3112        }
3113        /// Limits the maximum size of an encoded message.
3114        ///
3115        /// Default: `usize::MAX`
3116        #[must_use]
3117        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
3118            self.max_encoding_message_size = Some(limit);
3119            self
3120        }
3121    }
3122    impl<T, B> tonic::codegen::Service<http::Request<B>> for DdlServiceServer<T>
3123    where
3124        T: DdlService,
3125        B: Body + std::marker::Send + 'static,
3126        B::Error: Into<StdError> + std::marker::Send + 'static,
3127    {
3128        type Response = http::Response<tonic::body::Body>;
3129        type Error = std::convert::Infallible;
3130        type Future = BoxFuture<Self::Response, Self::Error>;
3131        fn poll_ready(
3132            &mut self,
3133            _cx: &mut Context<'_>,
3134        ) -> Poll<std::result::Result<(), Self::Error>> {
3135            Poll::Ready(Ok(()))
3136        }
3137        fn call(&mut self, req: http::Request<B>) -> Self::Future {
3138            match req.uri().path() {
3139                "/ddl_service.DdlService/CreateDatabase" => {
3140                    #[allow(non_camel_case_types)]
3141                    struct CreateDatabaseSvc<T: DdlService>(pub Arc<T>);
3142                    impl<
3143                        T: DdlService,
3144                    > tonic::server::UnaryService<super::CreateDatabaseRequest>
3145                    for CreateDatabaseSvc<T> {
3146                        type Response = super::CreateDatabaseResponse;
3147                        type Future = BoxFuture<
3148                            tonic::Response<Self::Response>,
3149                            tonic::Status,
3150                        >;
3151                        fn call(
3152                            &mut self,
3153                            request: tonic::Request<super::CreateDatabaseRequest>,
3154                        ) -> Self::Future {
3155                            let inner = Arc::clone(&self.0);
3156                            let fut = async move {
3157                                <T as DdlService>::create_database(&inner, request).await
3158                            };
3159                            Box::pin(fut)
3160                        }
3161                    }
3162                    let accept_compression_encodings = self.accept_compression_encodings;
3163                    let send_compression_encodings = self.send_compression_encodings;
3164                    let max_decoding_message_size = self.max_decoding_message_size;
3165                    let max_encoding_message_size = self.max_encoding_message_size;
3166                    let inner = self.inner.clone();
3167                    let fut = async move {
3168                        let method = CreateDatabaseSvc(inner);
3169                        let codec = tonic_prost::ProstCodec::default();
3170                        let mut grpc = tonic::server::Grpc::new(codec)
3171                            .apply_compression_config(
3172                                accept_compression_encodings,
3173                                send_compression_encodings,
3174                            )
3175                            .apply_max_message_size_config(
3176                                max_decoding_message_size,
3177                                max_encoding_message_size,
3178                            );
3179                        let res = grpc.unary(method, req).await;
3180                        Ok(res)
3181                    };
3182                    Box::pin(fut)
3183                }
3184                "/ddl_service.DdlService/DropDatabase" => {
3185                    #[allow(non_camel_case_types)]
3186                    struct DropDatabaseSvc<T: DdlService>(pub Arc<T>);
3187                    impl<
3188                        T: DdlService,
3189                    > tonic::server::UnaryService<super::DropDatabaseRequest>
3190                    for DropDatabaseSvc<T> {
3191                        type Response = super::DropDatabaseResponse;
3192                        type Future = BoxFuture<
3193                            tonic::Response<Self::Response>,
3194                            tonic::Status,
3195                        >;
3196                        fn call(
3197                            &mut self,
3198                            request: tonic::Request<super::DropDatabaseRequest>,
3199                        ) -> Self::Future {
3200                            let inner = Arc::clone(&self.0);
3201                            let fut = async move {
3202                                <T as DdlService>::drop_database(&inner, request).await
3203                            };
3204                            Box::pin(fut)
3205                        }
3206                    }
3207                    let accept_compression_encodings = self.accept_compression_encodings;
3208                    let send_compression_encodings = self.send_compression_encodings;
3209                    let max_decoding_message_size = self.max_decoding_message_size;
3210                    let max_encoding_message_size = self.max_encoding_message_size;
3211                    let inner = self.inner.clone();
3212                    let fut = async move {
3213                        let method = DropDatabaseSvc(inner);
3214                        let codec = tonic_prost::ProstCodec::default();
3215                        let mut grpc = tonic::server::Grpc::new(codec)
3216                            .apply_compression_config(
3217                                accept_compression_encodings,
3218                                send_compression_encodings,
3219                            )
3220                            .apply_max_message_size_config(
3221                                max_decoding_message_size,
3222                                max_encoding_message_size,
3223                            );
3224                        let res = grpc.unary(method, req).await;
3225                        Ok(res)
3226                    };
3227                    Box::pin(fut)
3228                }
3229                "/ddl_service.DdlService/CreateSchema" => {
3230                    #[allow(non_camel_case_types)]
3231                    struct CreateSchemaSvc<T: DdlService>(pub Arc<T>);
3232                    impl<
3233                        T: DdlService,
3234                    > tonic::server::UnaryService<super::CreateSchemaRequest>
3235                    for CreateSchemaSvc<T> {
3236                        type Response = super::CreateSchemaResponse;
3237                        type Future = BoxFuture<
3238                            tonic::Response<Self::Response>,
3239                            tonic::Status,
3240                        >;
3241                        fn call(
3242                            &mut self,
3243                            request: tonic::Request<super::CreateSchemaRequest>,
3244                        ) -> Self::Future {
3245                            let inner = Arc::clone(&self.0);
3246                            let fut = async move {
3247                                <T as DdlService>::create_schema(&inner, request).await
3248                            };
3249                            Box::pin(fut)
3250                        }
3251                    }
3252                    let accept_compression_encodings = self.accept_compression_encodings;
3253                    let send_compression_encodings = self.send_compression_encodings;
3254                    let max_decoding_message_size = self.max_decoding_message_size;
3255                    let max_encoding_message_size = self.max_encoding_message_size;
3256                    let inner = self.inner.clone();
3257                    let fut = async move {
3258                        let method = CreateSchemaSvc(inner);
3259                        let codec = tonic_prost::ProstCodec::default();
3260                        let mut grpc = tonic::server::Grpc::new(codec)
3261                            .apply_compression_config(
3262                                accept_compression_encodings,
3263                                send_compression_encodings,
3264                            )
3265                            .apply_max_message_size_config(
3266                                max_decoding_message_size,
3267                                max_encoding_message_size,
3268                            );
3269                        let res = grpc.unary(method, req).await;
3270                        Ok(res)
3271                    };
3272                    Box::pin(fut)
3273                }
3274                "/ddl_service.DdlService/DropSchema" => {
3275                    #[allow(non_camel_case_types)]
3276                    struct DropSchemaSvc<T: DdlService>(pub Arc<T>);
3277                    impl<
3278                        T: DdlService,
3279                    > tonic::server::UnaryService<super::DropSchemaRequest>
3280                    for DropSchemaSvc<T> {
3281                        type Response = super::DropSchemaResponse;
3282                        type Future = BoxFuture<
3283                            tonic::Response<Self::Response>,
3284                            tonic::Status,
3285                        >;
3286                        fn call(
3287                            &mut self,
3288                            request: tonic::Request<super::DropSchemaRequest>,
3289                        ) -> Self::Future {
3290                            let inner = Arc::clone(&self.0);
3291                            let fut = async move {
3292                                <T as DdlService>::drop_schema(&inner, request).await
3293                            };
3294                            Box::pin(fut)
3295                        }
3296                    }
3297                    let accept_compression_encodings = self.accept_compression_encodings;
3298                    let send_compression_encodings = self.send_compression_encodings;
3299                    let max_decoding_message_size = self.max_decoding_message_size;
3300                    let max_encoding_message_size = self.max_encoding_message_size;
3301                    let inner = self.inner.clone();
3302                    let fut = async move {
3303                        let method = DropSchemaSvc(inner);
3304                        let codec = tonic_prost::ProstCodec::default();
3305                        let mut grpc = tonic::server::Grpc::new(codec)
3306                            .apply_compression_config(
3307                                accept_compression_encodings,
3308                                send_compression_encodings,
3309                            )
3310                            .apply_max_message_size_config(
3311                                max_decoding_message_size,
3312                                max_encoding_message_size,
3313                            );
3314                        let res = grpc.unary(method, req).await;
3315                        Ok(res)
3316                    };
3317                    Box::pin(fut)
3318                }
3319                "/ddl_service.DdlService/CreateSource" => {
3320                    #[allow(non_camel_case_types)]
3321                    struct CreateSourceSvc<T: DdlService>(pub Arc<T>);
3322                    impl<
3323                        T: DdlService,
3324                    > tonic::server::UnaryService<super::CreateSourceRequest>
3325                    for CreateSourceSvc<T> {
3326                        type Response = super::CreateSourceResponse;
3327                        type Future = BoxFuture<
3328                            tonic::Response<Self::Response>,
3329                            tonic::Status,
3330                        >;
3331                        fn call(
3332                            &mut self,
3333                            request: tonic::Request<super::CreateSourceRequest>,
3334                        ) -> Self::Future {
3335                            let inner = Arc::clone(&self.0);
3336                            let fut = async move {
3337                                <T as DdlService>::create_source(&inner, request).await
3338                            };
3339                            Box::pin(fut)
3340                        }
3341                    }
3342                    let accept_compression_encodings = self.accept_compression_encodings;
3343                    let send_compression_encodings = self.send_compression_encodings;
3344                    let max_decoding_message_size = self.max_decoding_message_size;
3345                    let max_encoding_message_size = self.max_encoding_message_size;
3346                    let inner = self.inner.clone();
3347                    let fut = async move {
3348                        let method = CreateSourceSvc(inner);
3349                        let codec = tonic_prost::ProstCodec::default();
3350                        let mut grpc = tonic::server::Grpc::new(codec)
3351                            .apply_compression_config(
3352                                accept_compression_encodings,
3353                                send_compression_encodings,
3354                            )
3355                            .apply_max_message_size_config(
3356                                max_decoding_message_size,
3357                                max_encoding_message_size,
3358                            );
3359                        let res = grpc.unary(method, req).await;
3360                        Ok(res)
3361                    };
3362                    Box::pin(fut)
3363                }
3364                "/ddl_service.DdlService/DropSource" => {
3365                    #[allow(non_camel_case_types)]
3366                    struct DropSourceSvc<T: DdlService>(pub Arc<T>);
3367                    impl<
3368                        T: DdlService,
3369                    > tonic::server::UnaryService<super::DropSourceRequest>
3370                    for DropSourceSvc<T> {
3371                        type Response = super::DropSourceResponse;
3372                        type Future = BoxFuture<
3373                            tonic::Response<Self::Response>,
3374                            tonic::Status,
3375                        >;
3376                        fn call(
3377                            &mut self,
3378                            request: tonic::Request<super::DropSourceRequest>,
3379                        ) -> Self::Future {
3380                            let inner = Arc::clone(&self.0);
3381                            let fut = async move {
3382                                <T as DdlService>::drop_source(&inner, request).await
3383                            };
3384                            Box::pin(fut)
3385                        }
3386                    }
3387                    let accept_compression_encodings = self.accept_compression_encodings;
3388                    let send_compression_encodings = self.send_compression_encodings;
3389                    let max_decoding_message_size = self.max_decoding_message_size;
3390                    let max_encoding_message_size = self.max_encoding_message_size;
3391                    let inner = self.inner.clone();
3392                    let fut = async move {
3393                        let method = DropSourceSvc(inner);
3394                        let codec = tonic_prost::ProstCodec::default();
3395                        let mut grpc = tonic::server::Grpc::new(codec)
3396                            .apply_compression_config(
3397                                accept_compression_encodings,
3398                                send_compression_encodings,
3399                            )
3400                            .apply_max_message_size_config(
3401                                max_decoding_message_size,
3402                                max_encoding_message_size,
3403                            );
3404                        let res = grpc.unary(method, req).await;
3405                        Ok(res)
3406                    };
3407                    Box::pin(fut)
3408                }
3409                "/ddl_service.DdlService/CreateSink" => {
3410                    #[allow(non_camel_case_types)]
3411                    struct CreateSinkSvc<T: DdlService>(pub Arc<T>);
3412                    impl<
3413                        T: DdlService,
3414                    > tonic::server::UnaryService<super::CreateSinkRequest>
3415                    for CreateSinkSvc<T> {
3416                        type Response = super::CreateSinkResponse;
3417                        type Future = BoxFuture<
3418                            tonic::Response<Self::Response>,
3419                            tonic::Status,
3420                        >;
3421                        fn call(
3422                            &mut self,
3423                            request: tonic::Request<super::CreateSinkRequest>,
3424                        ) -> Self::Future {
3425                            let inner = Arc::clone(&self.0);
3426                            let fut = async move {
3427                                <T as DdlService>::create_sink(&inner, request).await
3428                            };
3429                            Box::pin(fut)
3430                        }
3431                    }
3432                    let accept_compression_encodings = self.accept_compression_encodings;
3433                    let send_compression_encodings = self.send_compression_encodings;
3434                    let max_decoding_message_size = self.max_decoding_message_size;
3435                    let max_encoding_message_size = self.max_encoding_message_size;
3436                    let inner = self.inner.clone();
3437                    let fut = async move {
3438                        let method = CreateSinkSvc(inner);
3439                        let codec = tonic_prost::ProstCodec::default();
3440                        let mut grpc = tonic::server::Grpc::new(codec)
3441                            .apply_compression_config(
3442                                accept_compression_encodings,
3443                                send_compression_encodings,
3444                            )
3445                            .apply_max_message_size_config(
3446                                max_decoding_message_size,
3447                                max_encoding_message_size,
3448                            );
3449                        let res = grpc.unary(method, req).await;
3450                        Ok(res)
3451                    };
3452                    Box::pin(fut)
3453                }
3454                "/ddl_service.DdlService/CreateSubscription" => {
3455                    #[allow(non_camel_case_types)]
3456                    struct CreateSubscriptionSvc<T: DdlService>(pub Arc<T>);
3457                    impl<
3458                        T: DdlService,
3459                    > tonic::server::UnaryService<super::CreateSubscriptionRequest>
3460                    for CreateSubscriptionSvc<T> {
3461                        type Response = super::CreateSubscriptionResponse;
3462                        type Future = BoxFuture<
3463                            tonic::Response<Self::Response>,
3464                            tonic::Status,
3465                        >;
3466                        fn call(
3467                            &mut self,
3468                            request: tonic::Request<super::CreateSubscriptionRequest>,
3469                        ) -> Self::Future {
3470                            let inner = Arc::clone(&self.0);
3471                            let fut = async move {
3472                                <T as DdlService>::create_subscription(&inner, request)
3473                                    .await
3474                            };
3475                            Box::pin(fut)
3476                        }
3477                    }
3478                    let accept_compression_encodings = self.accept_compression_encodings;
3479                    let send_compression_encodings = self.send_compression_encodings;
3480                    let max_decoding_message_size = self.max_decoding_message_size;
3481                    let max_encoding_message_size = self.max_encoding_message_size;
3482                    let inner = self.inner.clone();
3483                    let fut = async move {
3484                        let method = CreateSubscriptionSvc(inner);
3485                        let codec = tonic_prost::ProstCodec::default();
3486                        let mut grpc = tonic::server::Grpc::new(codec)
3487                            .apply_compression_config(
3488                                accept_compression_encodings,
3489                                send_compression_encodings,
3490                            )
3491                            .apply_max_message_size_config(
3492                                max_decoding_message_size,
3493                                max_encoding_message_size,
3494                            );
3495                        let res = grpc.unary(method, req).await;
3496                        Ok(res)
3497                    };
3498                    Box::pin(fut)
3499                }
3500                "/ddl_service.DdlService/DropSink" => {
3501                    #[allow(non_camel_case_types)]
3502                    struct DropSinkSvc<T: DdlService>(pub Arc<T>);
3503                    impl<
3504                        T: DdlService,
3505                    > tonic::server::UnaryService<super::DropSinkRequest>
3506                    for DropSinkSvc<T> {
3507                        type Response = super::DropSinkResponse;
3508                        type Future = BoxFuture<
3509                            tonic::Response<Self::Response>,
3510                            tonic::Status,
3511                        >;
3512                        fn call(
3513                            &mut self,
3514                            request: tonic::Request<super::DropSinkRequest>,
3515                        ) -> Self::Future {
3516                            let inner = Arc::clone(&self.0);
3517                            let fut = async move {
3518                                <T as DdlService>::drop_sink(&inner, request).await
3519                            };
3520                            Box::pin(fut)
3521                        }
3522                    }
3523                    let accept_compression_encodings = self.accept_compression_encodings;
3524                    let send_compression_encodings = self.send_compression_encodings;
3525                    let max_decoding_message_size = self.max_decoding_message_size;
3526                    let max_encoding_message_size = self.max_encoding_message_size;
3527                    let inner = self.inner.clone();
3528                    let fut = async move {
3529                        let method = DropSinkSvc(inner);
3530                        let codec = tonic_prost::ProstCodec::default();
3531                        let mut grpc = tonic::server::Grpc::new(codec)
3532                            .apply_compression_config(
3533                                accept_compression_encodings,
3534                                send_compression_encodings,
3535                            )
3536                            .apply_max_message_size_config(
3537                                max_decoding_message_size,
3538                                max_encoding_message_size,
3539                            );
3540                        let res = grpc.unary(method, req).await;
3541                        Ok(res)
3542                    };
3543                    Box::pin(fut)
3544                }
3545                "/ddl_service.DdlService/DropSubscription" => {
3546                    #[allow(non_camel_case_types)]
3547                    struct DropSubscriptionSvc<T: DdlService>(pub Arc<T>);
3548                    impl<
3549                        T: DdlService,
3550                    > tonic::server::UnaryService<super::DropSubscriptionRequest>
3551                    for DropSubscriptionSvc<T> {
3552                        type Response = super::DropSubscriptionResponse;
3553                        type Future = BoxFuture<
3554                            tonic::Response<Self::Response>,
3555                            tonic::Status,
3556                        >;
3557                        fn call(
3558                            &mut self,
3559                            request: tonic::Request<super::DropSubscriptionRequest>,
3560                        ) -> Self::Future {
3561                            let inner = Arc::clone(&self.0);
3562                            let fut = async move {
3563                                <T as DdlService>::drop_subscription(&inner, request).await
3564                            };
3565                            Box::pin(fut)
3566                        }
3567                    }
3568                    let accept_compression_encodings = self.accept_compression_encodings;
3569                    let send_compression_encodings = self.send_compression_encodings;
3570                    let max_decoding_message_size = self.max_decoding_message_size;
3571                    let max_encoding_message_size = self.max_encoding_message_size;
3572                    let inner = self.inner.clone();
3573                    let fut = async move {
3574                        let method = DropSubscriptionSvc(inner);
3575                        let codec = tonic_prost::ProstCodec::default();
3576                        let mut grpc = tonic::server::Grpc::new(codec)
3577                            .apply_compression_config(
3578                                accept_compression_encodings,
3579                                send_compression_encodings,
3580                            )
3581                            .apply_max_message_size_config(
3582                                max_decoding_message_size,
3583                                max_encoding_message_size,
3584                            );
3585                        let res = grpc.unary(method, req).await;
3586                        Ok(res)
3587                    };
3588                    Box::pin(fut)
3589                }
3590                "/ddl_service.DdlService/CreateMaterializedView" => {
3591                    #[allow(non_camel_case_types)]
3592                    struct CreateMaterializedViewSvc<T: DdlService>(pub Arc<T>);
3593                    impl<
3594                        T: DdlService,
3595                    > tonic::server::UnaryService<super::CreateMaterializedViewRequest>
3596                    for CreateMaterializedViewSvc<T> {
3597                        type Response = super::CreateMaterializedViewResponse;
3598                        type Future = BoxFuture<
3599                            tonic::Response<Self::Response>,
3600                            tonic::Status,
3601                        >;
3602                        fn call(
3603                            &mut self,
3604                            request: tonic::Request<super::CreateMaterializedViewRequest>,
3605                        ) -> Self::Future {
3606                            let inner = Arc::clone(&self.0);
3607                            let fut = async move {
3608                                <T as DdlService>::create_materialized_view(&inner, request)
3609                                    .await
3610                            };
3611                            Box::pin(fut)
3612                        }
3613                    }
3614                    let accept_compression_encodings = self.accept_compression_encodings;
3615                    let send_compression_encodings = self.send_compression_encodings;
3616                    let max_decoding_message_size = self.max_decoding_message_size;
3617                    let max_encoding_message_size = self.max_encoding_message_size;
3618                    let inner = self.inner.clone();
3619                    let fut = async move {
3620                        let method = CreateMaterializedViewSvc(inner);
3621                        let codec = tonic_prost::ProstCodec::default();
3622                        let mut grpc = tonic::server::Grpc::new(codec)
3623                            .apply_compression_config(
3624                                accept_compression_encodings,
3625                                send_compression_encodings,
3626                            )
3627                            .apply_max_message_size_config(
3628                                max_decoding_message_size,
3629                                max_encoding_message_size,
3630                            );
3631                        let res = grpc.unary(method, req).await;
3632                        Ok(res)
3633                    };
3634                    Box::pin(fut)
3635                }
3636                "/ddl_service.DdlService/DropMaterializedView" => {
3637                    #[allow(non_camel_case_types)]
3638                    struct DropMaterializedViewSvc<T: DdlService>(pub Arc<T>);
3639                    impl<
3640                        T: DdlService,
3641                    > tonic::server::UnaryService<super::DropMaterializedViewRequest>
3642                    for DropMaterializedViewSvc<T> {
3643                        type Response = super::DropMaterializedViewResponse;
3644                        type Future = BoxFuture<
3645                            tonic::Response<Self::Response>,
3646                            tonic::Status,
3647                        >;
3648                        fn call(
3649                            &mut self,
3650                            request: tonic::Request<super::DropMaterializedViewRequest>,
3651                        ) -> Self::Future {
3652                            let inner = Arc::clone(&self.0);
3653                            let fut = async move {
3654                                <T as DdlService>::drop_materialized_view(&inner, request)
3655                                    .await
3656                            };
3657                            Box::pin(fut)
3658                        }
3659                    }
3660                    let accept_compression_encodings = self.accept_compression_encodings;
3661                    let send_compression_encodings = self.send_compression_encodings;
3662                    let max_decoding_message_size = self.max_decoding_message_size;
3663                    let max_encoding_message_size = self.max_encoding_message_size;
3664                    let inner = self.inner.clone();
3665                    let fut = async move {
3666                        let method = DropMaterializedViewSvc(inner);
3667                        let codec = tonic_prost::ProstCodec::default();
3668                        let mut grpc = tonic::server::Grpc::new(codec)
3669                            .apply_compression_config(
3670                                accept_compression_encodings,
3671                                send_compression_encodings,
3672                            )
3673                            .apply_max_message_size_config(
3674                                max_decoding_message_size,
3675                                max_encoding_message_size,
3676                            );
3677                        let res = grpc.unary(method, req).await;
3678                        Ok(res)
3679                    };
3680                    Box::pin(fut)
3681                }
3682                "/ddl_service.DdlService/CreateTable" => {
3683                    #[allow(non_camel_case_types)]
3684                    struct CreateTableSvc<T: DdlService>(pub Arc<T>);
3685                    impl<
3686                        T: DdlService,
3687                    > tonic::server::UnaryService<super::CreateTableRequest>
3688                    for CreateTableSvc<T> {
3689                        type Response = super::CreateTableResponse;
3690                        type Future = BoxFuture<
3691                            tonic::Response<Self::Response>,
3692                            tonic::Status,
3693                        >;
3694                        fn call(
3695                            &mut self,
3696                            request: tonic::Request<super::CreateTableRequest>,
3697                        ) -> Self::Future {
3698                            let inner = Arc::clone(&self.0);
3699                            let fut = async move {
3700                                <T as DdlService>::create_table(&inner, request).await
3701                            };
3702                            Box::pin(fut)
3703                        }
3704                    }
3705                    let accept_compression_encodings = self.accept_compression_encodings;
3706                    let send_compression_encodings = self.send_compression_encodings;
3707                    let max_decoding_message_size = self.max_decoding_message_size;
3708                    let max_encoding_message_size = self.max_encoding_message_size;
3709                    let inner = self.inner.clone();
3710                    let fut = async move {
3711                        let method = CreateTableSvc(inner);
3712                        let codec = tonic_prost::ProstCodec::default();
3713                        let mut grpc = tonic::server::Grpc::new(codec)
3714                            .apply_compression_config(
3715                                accept_compression_encodings,
3716                                send_compression_encodings,
3717                            )
3718                            .apply_max_message_size_config(
3719                                max_decoding_message_size,
3720                                max_encoding_message_size,
3721                            );
3722                        let res = grpc.unary(method, req).await;
3723                        Ok(res)
3724                    };
3725                    Box::pin(fut)
3726                }
3727                "/ddl_service.DdlService/CreateIcebergTable" => {
3728                    #[allow(non_camel_case_types)]
3729                    struct CreateIcebergTableSvc<T: DdlService>(pub Arc<T>);
3730                    impl<
3731                        T: DdlService,
3732                    > tonic::server::UnaryService<super::CreateIcebergTableRequest>
3733                    for CreateIcebergTableSvc<T> {
3734                        type Response = super::CreateIcebergTableResponse;
3735                        type Future = BoxFuture<
3736                            tonic::Response<Self::Response>,
3737                            tonic::Status,
3738                        >;
3739                        fn call(
3740                            &mut self,
3741                            request: tonic::Request<super::CreateIcebergTableRequest>,
3742                        ) -> Self::Future {
3743                            let inner = Arc::clone(&self.0);
3744                            let fut = async move {
3745                                <T as DdlService>::create_iceberg_table(&inner, request)
3746                                    .await
3747                            };
3748                            Box::pin(fut)
3749                        }
3750                    }
3751                    let accept_compression_encodings = self.accept_compression_encodings;
3752                    let send_compression_encodings = self.send_compression_encodings;
3753                    let max_decoding_message_size = self.max_decoding_message_size;
3754                    let max_encoding_message_size = self.max_encoding_message_size;
3755                    let inner = self.inner.clone();
3756                    let fut = async move {
3757                        let method = CreateIcebergTableSvc(inner);
3758                        let codec = tonic_prost::ProstCodec::default();
3759                        let mut grpc = tonic::server::Grpc::new(codec)
3760                            .apply_compression_config(
3761                                accept_compression_encodings,
3762                                send_compression_encodings,
3763                            )
3764                            .apply_max_message_size_config(
3765                                max_decoding_message_size,
3766                                max_encoding_message_size,
3767                            );
3768                        let res = grpc.unary(method, req).await;
3769                        Ok(res)
3770                    };
3771                    Box::pin(fut)
3772                }
3773                "/ddl_service.DdlService/CreateSecret" => {
3774                    #[allow(non_camel_case_types)]
3775                    struct CreateSecretSvc<T: DdlService>(pub Arc<T>);
3776                    impl<
3777                        T: DdlService,
3778                    > tonic::server::UnaryService<super::CreateSecretRequest>
3779                    for CreateSecretSvc<T> {
3780                        type Response = super::CreateSecretResponse;
3781                        type Future = BoxFuture<
3782                            tonic::Response<Self::Response>,
3783                            tonic::Status,
3784                        >;
3785                        fn call(
3786                            &mut self,
3787                            request: tonic::Request<super::CreateSecretRequest>,
3788                        ) -> Self::Future {
3789                            let inner = Arc::clone(&self.0);
3790                            let fut = async move {
3791                                <T as DdlService>::create_secret(&inner, request).await
3792                            };
3793                            Box::pin(fut)
3794                        }
3795                    }
3796                    let accept_compression_encodings = self.accept_compression_encodings;
3797                    let send_compression_encodings = self.send_compression_encodings;
3798                    let max_decoding_message_size = self.max_decoding_message_size;
3799                    let max_encoding_message_size = self.max_encoding_message_size;
3800                    let inner = self.inner.clone();
3801                    let fut = async move {
3802                        let method = CreateSecretSvc(inner);
3803                        let codec = tonic_prost::ProstCodec::default();
3804                        let mut grpc = tonic::server::Grpc::new(codec)
3805                            .apply_compression_config(
3806                                accept_compression_encodings,
3807                                send_compression_encodings,
3808                            )
3809                            .apply_max_message_size_config(
3810                                max_decoding_message_size,
3811                                max_encoding_message_size,
3812                            );
3813                        let res = grpc.unary(method, req).await;
3814                        Ok(res)
3815                    };
3816                    Box::pin(fut)
3817                }
3818                "/ddl_service.DdlService/DropSecret" => {
3819                    #[allow(non_camel_case_types)]
3820                    struct DropSecretSvc<T: DdlService>(pub Arc<T>);
3821                    impl<
3822                        T: DdlService,
3823                    > tonic::server::UnaryService<super::DropSecretRequest>
3824                    for DropSecretSvc<T> {
3825                        type Response = super::DropSecretResponse;
3826                        type Future = BoxFuture<
3827                            tonic::Response<Self::Response>,
3828                            tonic::Status,
3829                        >;
3830                        fn call(
3831                            &mut self,
3832                            request: tonic::Request<super::DropSecretRequest>,
3833                        ) -> Self::Future {
3834                            let inner = Arc::clone(&self.0);
3835                            let fut = async move {
3836                                <T as DdlService>::drop_secret(&inner, request).await
3837                            };
3838                            Box::pin(fut)
3839                        }
3840                    }
3841                    let accept_compression_encodings = self.accept_compression_encodings;
3842                    let send_compression_encodings = self.send_compression_encodings;
3843                    let max_decoding_message_size = self.max_decoding_message_size;
3844                    let max_encoding_message_size = self.max_encoding_message_size;
3845                    let inner = self.inner.clone();
3846                    let fut = async move {
3847                        let method = DropSecretSvc(inner);
3848                        let codec = tonic_prost::ProstCodec::default();
3849                        let mut grpc = tonic::server::Grpc::new(codec)
3850                            .apply_compression_config(
3851                                accept_compression_encodings,
3852                                send_compression_encodings,
3853                            )
3854                            .apply_max_message_size_config(
3855                                max_decoding_message_size,
3856                                max_encoding_message_size,
3857                            );
3858                        let res = grpc.unary(method, req).await;
3859                        Ok(res)
3860                    };
3861                    Box::pin(fut)
3862                }
3863                "/ddl_service.DdlService/AlterSecret" => {
3864                    #[allow(non_camel_case_types)]
3865                    struct AlterSecretSvc<T: DdlService>(pub Arc<T>);
3866                    impl<
3867                        T: DdlService,
3868                    > tonic::server::UnaryService<super::AlterSecretRequest>
3869                    for AlterSecretSvc<T> {
3870                        type Response = super::AlterSecretResponse;
3871                        type Future = BoxFuture<
3872                            tonic::Response<Self::Response>,
3873                            tonic::Status,
3874                        >;
3875                        fn call(
3876                            &mut self,
3877                            request: tonic::Request<super::AlterSecretRequest>,
3878                        ) -> Self::Future {
3879                            let inner = Arc::clone(&self.0);
3880                            let fut = async move {
3881                                <T as DdlService>::alter_secret(&inner, request).await
3882                            };
3883                            Box::pin(fut)
3884                        }
3885                    }
3886                    let accept_compression_encodings = self.accept_compression_encodings;
3887                    let send_compression_encodings = self.send_compression_encodings;
3888                    let max_decoding_message_size = self.max_decoding_message_size;
3889                    let max_encoding_message_size = self.max_encoding_message_size;
3890                    let inner = self.inner.clone();
3891                    let fut = async move {
3892                        let method = AlterSecretSvc(inner);
3893                        let codec = tonic_prost::ProstCodec::default();
3894                        let mut grpc = tonic::server::Grpc::new(codec)
3895                            .apply_compression_config(
3896                                accept_compression_encodings,
3897                                send_compression_encodings,
3898                            )
3899                            .apply_max_message_size_config(
3900                                max_decoding_message_size,
3901                                max_encoding_message_size,
3902                            );
3903                        let res = grpc.unary(method, req).await;
3904                        Ok(res)
3905                    };
3906                    Box::pin(fut)
3907                }
3908                "/ddl_service.DdlService/AlterName" => {
3909                    #[allow(non_camel_case_types)]
3910                    struct AlterNameSvc<T: DdlService>(pub Arc<T>);
3911                    impl<
3912                        T: DdlService,
3913                    > tonic::server::UnaryService<super::AlterNameRequest>
3914                    for AlterNameSvc<T> {
3915                        type Response = super::AlterNameResponse;
3916                        type Future = BoxFuture<
3917                            tonic::Response<Self::Response>,
3918                            tonic::Status,
3919                        >;
3920                        fn call(
3921                            &mut self,
3922                            request: tonic::Request<super::AlterNameRequest>,
3923                        ) -> Self::Future {
3924                            let inner = Arc::clone(&self.0);
3925                            let fut = async move {
3926                                <T as DdlService>::alter_name(&inner, request).await
3927                            };
3928                            Box::pin(fut)
3929                        }
3930                    }
3931                    let accept_compression_encodings = self.accept_compression_encodings;
3932                    let send_compression_encodings = self.send_compression_encodings;
3933                    let max_decoding_message_size = self.max_decoding_message_size;
3934                    let max_encoding_message_size = self.max_encoding_message_size;
3935                    let inner = self.inner.clone();
3936                    let fut = async move {
3937                        let method = AlterNameSvc(inner);
3938                        let codec = tonic_prost::ProstCodec::default();
3939                        let mut grpc = tonic::server::Grpc::new(codec)
3940                            .apply_compression_config(
3941                                accept_compression_encodings,
3942                                send_compression_encodings,
3943                            )
3944                            .apply_max_message_size_config(
3945                                max_decoding_message_size,
3946                                max_encoding_message_size,
3947                            );
3948                        let res = grpc.unary(method, req).await;
3949                        Ok(res)
3950                    };
3951                    Box::pin(fut)
3952                }
3953                "/ddl_service.DdlService/AlterSource" => {
3954                    #[allow(non_camel_case_types)]
3955                    struct AlterSourceSvc<T: DdlService>(pub Arc<T>);
3956                    impl<
3957                        T: DdlService,
3958                    > tonic::server::UnaryService<super::AlterSourceRequest>
3959                    for AlterSourceSvc<T> {
3960                        type Response = super::AlterSourceResponse;
3961                        type Future = BoxFuture<
3962                            tonic::Response<Self::Response>,
3963                            tonic::Status,
3964                        >;
3965                        fn call(
3966                            &mut self,
3967                            request: tonic::Request<super::AlterSourceRequest>,
3968                        ) -> Self::Future {
3969                            let inner = Arc::clone(&self.0);
3970                            let fut = async move {
3971                                <T as DdlService>::alter_source(&inner, request).await
3972                            };
3973                            Box::pin(fut)
3974                        }
3975                    }
3976                    let accept_compression_encodings = self.accept_compression_encodings;
3977                    let send_compression_encodings = self.send_compression_encodings;
3978                    let max_decoding_message_size = self.max_decoding_message_size;
3979                    let max_encoding_message_size = self.max_encoding_message_size;
3980                    let inner = self.inner.clone();
3981                    let fut = async move {
3982                        let method = AlterSourceSvc(inner);
3983                        let codec = tonic_prost::ProstCodec::default();
3984                        let mut grpc = tonic::server::Grpc::new(codec)
3985                            .apply_compression_config(
3986                                accept_compression_encodings,
3987                                send_compression_encodings,
3988                            )
3989                            .apply_max_message_size_config(
3990                                max_decoding_message_size,
3991                                max_encoding_message_size,
3992                            );
3993                        let res = grpc.unary(method, req).await;
3994                        Ok(res)
3995                    };
3996                    Box::pin(fut)
3997                }
3998                "/ddl_service.DdlService/ResetSource" => {
3999                    #[allow(non_camel_case_types)]
4000                    struct ResetSourceSvc<T: DdlService>(pub Arc<T>);
4001                    impl<
4002                        T: DdlService,
4003                    > tonic::server::UnaryService<super::ResetSourceRequest>
4004                    for ResetSourceSvc<T> {
4005                        type Response = super::ResetSourceResponse;
4006                        type Future = BoxFuture<
4007                            tonic::Response<Self::Response>,
4008                            tonic::Status,
4009                        >;
4010                        fn call(
4011                            &mut self,
4012                            request: tonic::Request<super::ResetSourceRequest>,
4013                        ) -> Self::Future {
4014                            let inner = Arc::clone(&self.0);
4015                            let fut = async move {
4016                                <T as DdlService>::reset_source(&inner, request).await
4017                            };
4018                            Box::pin(fut)
4019                        }
4020                    }
4021                    let accept_compression_encodings = self.accept_compression_encodings;
4022                    let send_compression_encodings = self.send_compression_encodings;
4023                    let max_decoding_message_size = self.max_decoding_message_size;
4024                    let max_encoding_message_size = self.max_encoding_message_size;
4025                    let inner = self.inner.clone();
4026                    let fut = async move {
4027                        let method = ResetSourceSvc(inner);
4028                        let codec = tonic_prost::ProstCodec::default();
4029                        let mut grpc = tonic::server::Grpc::new(codec)
4030                            .apply_compression_config(
4031                                accept_compression_encodings,
4032                                send_compression_encodings,
4033                            )
4034                            .apply_max_message_size_config(
4035                                max_decoding_message_size,
4036                                max_encoding_message_size,
4037                            );
4038                        let res = grpc.unary(method, req).await;
4039                        Ok(res)
4040                    };
4041                    Box::pin(fut)
4042                }
4043                "/ddl_service.DdlService/AlterOwner" => {
4044                    #[allow(non_camel_case_types)]
4045                    struct AlterOwnerSvc<T: DdlService>(pub Arc<T>);
4046                    impl<
4047                        T: DdlService,
4048                    > tonic::server::UnaryService<super::AlterOwnerRequest>
4049                    for AlterOwnerSvc<T> {
4050                        type Response = super::AlterOwnerResponse;
4051                        type Future = BoxFuture<
4052                            tonic::Response<Self::Response>,
4053                            tonic::Status,
4054                        >;
4055                        fn call(
4056                            &mut self,
4057                            request: tonic::Request<super::AlterOwnerRequest>,
4058                        ) -> Self::Future {
4059                            let inner = Arc::clone(&self.0);
4060                            let fut = async move {
4061                                <T as DdlService>::alter_owner(&inner, request).await
4062                            };
4063                            Box::pin(fut)
4064                        }
4065                    }
4066                    let accept_compression_encodings = self.accept_compression_encodings;
4067                    let send_compression_encodings = self.send_compression_encodings;
4068                    let max_decoding_message_size = self.max_decoding_message_size;
4069                    let max_encoding_message_size = self.max_encoding_message_size;
4070                    let inner = self.inner.clone();
4071                    let fut = async move {
4072                        let method = AlterOwnerSvc(inner);
4073                        let codec = tonic_prost::ProstCodec::default();
4074                        let mut grpc = tonic::server::Grpc::new(codec)
4075                            .apply_compression_config(
4076                                accept_compression_encodings,
4077                                send_compression_encodings,
4078                            )
4079                            .apply_max_message_size_config(
4080                                max_decoding_message_size,
4081                                max_encoding_message_size,
4082                            );
4083                        let res = grpc.unary(method, req).await;
4084                        Ok(res)
4085                    };
4086                    Box::pin(fut)
4087                }
4088                "/ddl_service.DdlService/AlterSubscriptionRetention" => {
4089                    #[allow(non_camel_case_types)]
4090                    struct AlterSubscriptionRetentionSvc<T: DdlService>(pub Arc<T>);
4091                    impl<
4092                        T: DdlService,
4093                    > tonic::server::UnaryService<
4094                        super::AlterSubscriptionRetentionRequest,
4095                    > for AlterSubscriptionRetentionSvc<T> {
4096                        type Response = super::AlterSubscriptionRetentionResponse;
4097                        type Future = BoxFuture<
4098                            tonic::Response<Self::Response>,
4099                            tonic::Status,
4100                        >;
4101                        fn call(
4102                            &mut self,
4103                            request: tonic::Request<
4104                                super::AlterSubscriptionRetentionRequest,
4105                            >,
4106                        ) -> Self::Future {
4107                            let inner = Arc::clone(&self.0);
4108                            let fut = async move {
4109                                <T as DdlService>::alter_subscription_retention(
4110                                        &inner,
4111                                        request,
4112                                    )
4113                                    .await
4114                            };
4115                            Box::pin(fut)
4116                        }
4117                    }
4118                    let accept_compression_encodings = self.accept_compression_encodings;
4119                    let send_compression_encodings = self.send_compression_encodings;
4120                    let max_decoding_message_size = self.max_decoding_message_size;
4121                    let max_encoding_message_size = self.max_encoding_message_size;
4122                    let inner = self.inner.clone();
4123                    let fut = async move {
4124                        let method = AlterSubscriptionRetentionSvc(inner);
4125                        let codec = tonic_prost::ProstCodec::default();
4126                        let mut grpc = tonic::server::Grpc::new(codec)
4127                            .apply_compression_config(
4128                                accept_compression_encodings,
4129                                send_compression_encodings,
4130                            )
4131                            .apply_max_message_size_config(
4132                                max_decoding_message_size,
4133                                max_encoding_message_size,
4134                            );
4135                        let res = grpc.unary(method, req).await;
4136                        Ok(res)
4137                    };
4138                    Box::pin(fut)
4139                }
4140                "/ddl_service.DdlService/AlterSetSchema" => {
4141                    #[allow(non_camel_case_types)]
4142                    struct AlterSetSchemaSvc<T: DdlService>(pub Arc<T>);
4143                    impl<
4144                        T: DdlService,
4145                    > tonic::server::UnaryService<super::AlterSetSchemaRequest>
4146                    for AlterSetSchemaSvc<T> {
4147                        type Response = super::AlterSetSchemaResponse;
4148                        type Future = BoxFuture<
4149                            tonic::Response<Self::Response>,
4150                            tonic::Status,
4151                        >;
4152                        fn call(
4153                            &mut self,
4154                            request: tonic::Request<super::AlterSetSchemaRequest>,
4155                        ) -> Self::Future {
4156                            let inner = Arc::clone(&self.0);
4157                            let fut = async move {
4158                                <T as DdlService>::alter_set_schema(&inner, request).await
4159                            };
4160                            Box::pin(fut)
4161                        }
4162                    }
4163                    let accept_compression_encodings = self.accept_compression_encodings;
4164                    let send_compression_encodings = self.send_compression_encodings;
4165                    let max_decoding_message_size = self.max_decoding_message_size;
4166                    let max_encoding_message_size = self.max_encoding_message_size;
4167                    let inner = self.inner.clone();
4168                    let fut = async move {
4169                        let method = AlterSetSchemaSvc(inner);
4170                        let codec = tonic_prost::ProstCodec::default();
4171                        let mut grpc = tonic::server::Grpc::new(codec)
4172                            .apply_compression_config(
4173                                accept_compression_encodings,
4174                                send_compression_encodings,
4175                            )
4176                            .apply_max_message_size_config(
4177                                max_decoding_message_size,
4178                                max_encoding_message_size,
4179                            );
4180                        let res = grpc.unary(method, req).await;
4181                        Ok(res)
4182                    };
4183                    Box::pin(fut)
4184                }
4185                "/ddl_service.DdlService/AlterParallelism" => {
4186                    #[allow(non_camel_case_types)]
4187                    struct AlterParallelismSvc<T: DdlService>(pub Arc<T>);
4188                    impl<
4189                        T: DdlService,
4190                    > tonic::server::UnaryService<super::AlterParallelismRequest>
4191                    for AlterParallelismSvc<T> {
4192                        type Response = super::AlterParallelismResponse;
4193                        type Future = BoxFuture<
4194                            tonic::Response<Self::Response>,
4195                            tonic::Status,
4196                        >;
4197                        fn call(
4198                            &mut self,
4199                            request: tonic::Request<super::AlterParallelismRequest>,
4200                        ) -> Self::Future {
4201                            let inner = Arc::clone(&self.0);
4202                            let fut = async move {
4203                                <T as DdlService>::alter_parallelism(&inner, request).await
4204                            };
4205                            Box::pin(fut)
4206                        }
4207                    }
4208                    let accept_compression_encodings = self.accept_compression_encodings;
4209                    let send_compression_encodings = self.send_compression_encodings;
4210                    let max_decoding_message_size = self.max_decoding_message_size;
4211                    let max_encoding_message_size = self.max_encoding_message_size;
4212                    let inner = self.inner.clone();
4213                    let fut = async move {
4214                        let method = AlterParallelismSvc(inner);
4215                        let codec = tonic_prost::ProstCodec::default();
4216                        let mut grpc = tonic::server::Grpc::new(codec)
4217                            .apply_compression_config(
4218                                accept_compression_encodings,
4219                                send_compression_encodings,
4220                            )
4221                            .apply_max_message_size_config(
4222                                max_decoding_message_size,
4223                                max_encoding_message_size,
4224                            );
4225                        let res = grpc.unary(method, req).await;
4226                        Ok(res)
4227                    };
4228                    Box::pin(fut)
4229                }
4230                "/ddl_service.DdlService/AlterBackfillParallelism" => {
4231                    #[allow(non_camel_case_types)]
4232                    struct AlterBackfillParallelismSvc<T: DdlService>(pub Arc<T>);
4233                    impl<
4234                        T: DdlService,
4235                    > tonic::server::UnaryService<super::AlterBackfillParallelismRequest>
4236                    for AlterBackfillParallelismSvc<T> {
4237                        type Response = super::AlterBackfillParallelismResponse;
4238                        type Future = BoxFuture<
4239                            tonic::Response<Self::Response>,
4240                            tonic::Status,
4241                        >;
4242                        fn call(
4243                            &mut self,
4244                            request: tonic::Request<
4245                                super::AlterBackfillParallelismRequest,
4246                            >,
4247                        ) -> Self::Future {
4248                            let inner = Arc::clone(&self.0);
4249                            let fut = async move {
4250                                <T as DdlService>::alter_backfill_parallelism(
4251                                        &inner,
4252                                        request,
4253                                    )
4254                                    .await
4255                            };
4256                            Box::pin(fut)
4257                        }
4258                    }
4259                    let accept_compression_encodings = self.accept_compression_encodings;
4260                    let send_compression_encodings = self.send_compression_encodings;
4261                    let max_decoding_message_size = self.max_decoding_message_size;
4262                    let max_encoding_message_size = self.max_encoding_message_size;
4263                    let inner = self.inner.clone();
4264                    let fut = async move {
4265                        let method = AlterBackfillParallelismSvc(inner);
4266                        let codec = tonic_prost::ProstCodec::default();
4267                        let mut grpc = tonic::server::Grpc::new(codec)
4268                            .apply_compression_config(
4269                                accept_compression_encodings,
4270                                send_compression_encodings,
4271                            )
4272                            .apply_max_message_size_config(
4273                                max_decoding_message_size,
4274                                max_encoding_message_size,
4275                            );
4276                        let res = grpc.unary(method, req).await;
4277                        Ok(res)
4278                    };
4279                    Box::pin(fut)
4280                }
4281                "/ddl_service.DdlService/AlterFragmentParallelism" => {
4282                    #[allow(non_camel_case_types)]
4283                    struct AlterFragmentParallelismSvc<T: DdlService>(pub Arc<T>);
4284                    impl<
4285                        T: DdlService,
4286                    > tonic::server::UnaryService<super::AlterFragmentParallelismRequest>
4287                    for AlterFragmentParallelismSvc<T> {
4288                        type Response = super::AlterFragmentParallelismResponse;
4289                        type Future = BoxFuture<
4290                            tonic::Response<Self::Response>,
4291                            tonic::Status,
4292                        >;
4293                        fn call(
4294                            &mut self,
4295                            request: tonic::Request<
4296                                super::AlterFragmentParallelismRequest,
4297                            >,
4298                        ) -> Self::Future {
4299                            let inner = Arc::clone(&self.0);
4300                            let fut = async move {
4301                                <T as DdlService>::alter_fragment_parallelism(
4302                                        &inner,
4303                                        request,
4304                                    )
4305                                    .await
4306                            };
4307                            Box::pin(fut)
4308                        }
4309                    }
4310                    let accept_compression_encodings = self.accept_compression_encodings;
4311                    let send_compression_encodings = self.send_compression_encodings;
4312                    let max_decoding_message_size = self.max_decoding_message_size;
4313                    let max_encoding_message_size = self.max_encoding_message_size;
4314                    let inner = self.inner.clone();
4315                    let fut = async move {
4316                        let method = AlterFragmentParallelismSvc(inner);
4317                        let codec = tonic_prost::ProstCodec::default();
4318                        let mut grpc = tonic::server::Grpc::new(codec)
4319                            .apply_compression_config(
4320                                accept_compression_encodings,
4321                                send_compression_encodings,
4322                            )
4323                            .apply_max_message_size_config(
4324                                max_decoding_message_size,
4325                                max_encoding_message_size,
4326                            );
4327                        let res = grpc.unary(method, req).await;
4328                        Ok(res)
4329                    };
4330                    Box::pin(fut)
4331                }
4332                "/ddl_service.DdlService/AlterResourceGroup" => {
4333                    #[allow(non_camel_case_types)]
4334                    struct AlterResourceGroupSvc<T: DdlService>(pub Arc<T>);
4335                    impl<
4336                        T: DdlService,
4337                    > tonic::server::UnaryService<super::AlterResourceGroupRequest>
4338                    for AlterResourceGroupSvc<T> {
4339                        type Response = super::AlterResourceGroupResponse;
4340                        type Future = BoxFuture<
4341                            tonic::Response<Self::Response>,
4342                            tonic::Status,
4343                        >;
4344                        fn call(
4345                            &mut self,
4346                            request: tonic::Request<super::AlterResourceGroupRequest>,
4347                        ) -> Self::Future {
4348                            let inner = Arc::clone(&self.0);
4349                            let fut = async move {
4350                                <T as DdlService>::alter_resource_group(&inner, request)
4351                                    .await
4352                            };
4353                            Box::pin(fut)
4354                        }
4355                    }
4356                    let accept_compression_encodings = self.accept_compression_encodings;
4357                    let send_compression_encodings = self.send_compression_encodings;
4358                    let max_decoding_message_size = self.max_decoding_message_size;
4359                    let max_encoding_message_size = self.max_encoding_message_size;
4360                    let inner = self.inner.clone();
4361                    let fut = async move {
4362                        let method = AlterResourceGroupSvc(inner);
4363                        let codec = tonic_prost::ProstCodec::default();
4364                        let mut grpc = tonic::server::Grpc::new(codec)
4365                            .apply_compression_config(
4366                                accept_compression_encodings,
4367                                send_compression_encodings,
4368                            )
4369                            .apply_max_message_size_config(
4370                                max_decoding_message_size,
4371                                max_encoding_message_size,
4372                            );
4373                        let res = grpc.unary(method, req).await;
4374                        Ok(res)
4375                    };
4376                    Box::pin(fut)
4377                }
4378                "/ddl_service.DdlService/AlterDatabaseResourceGroup" => {
4379                    #[allow(non_camel_case_types)]
4380                    struct AlterDatabaseResourceGroupSvc<T: DdlService>(pub Arc<T>);
4381                    impl<
4382                        T: DdlService,
4383                    > tonic::server::UnaryService<
4384                        super::AlterDatabaseResourceGroupRequest,
4385                    > for AlterDatabaseResourceGroupSvc<T> {
4386                        type Response = super::AlterDatabaseResourceGroupResponse;
4387                        type Future = BoxFuture<
4388                            tonic::Response<Self::Response>,
4389                            tonic::Status,
4390                        >;
4391                        fn call(
4392                            &mut self,
4393                            request: tonic::Request<
4394                                super::AlterDatabaseResourceGroupRequest,
4395                            >,
4396                        ) -> Self::Future {
4397                            let inner = Arc::clone(&self.0);
4398                            let fut = async move {
4399                                <T as DdlService>::alter_database_resource_group(
4400                                        &inner,
4401                                        request,
4402                                    )
4403                                    .await
4404                            };
4405                            Box::pin(fut)
4406                        }
4407                    }
4408                    let accept_compression_encodings = self.accept_compression_encodings;
4409                    let send_compression_encodings = self.send_compression_encodings;
4410                    let max_decoding_message_size = self.max_decoding_message_size;
4411                    let max_encoding_message_size = self.max_encoding_message_size;
4412                    let inner = self.inner.clone();
4413                    let fut = async move {
4414                        let method = AlterDatabaseResourceGroupSvc(inner);
4415                        let codec = tonic_prost::ProstCodec::default();
4416                        let mut grpc = tonic::server::Grpc::new(codec)
4417                            .apply_compression_config(
4418                                accept_compression_encodings,
4419                                send_compression_encodings,
4420                            )
4421                            .apply_max_message_size_config(
4422                                max_decoding_message_size,
4423                                max_encoding_message_size,
4424                            );
4425                        let res = grpc.unary(method, req).await;
4426                        Ok(res)
4427                    };
4428                    Box::pin(fut)
4429                }
4430                "/ddl_service.DdlService/DropTable" => {
4431                    #[allow(non_camel_case_types)]
4432                    struct DropTableSvc<T: DdlService>(pub Arc<T>);
4433                    impl<
4434                        T: DdlService,
4435                    > tonic::server::UnaryService<super::DropTableRequest>
4436                    for DropTableSvc<T> {
4437                        type Response = super::DropTableResponse;
4438                        type Future = BoxFuture<
4439                            tonic::Response<Self::Response>,
4440                            tonic::Status,
4441                        >;
4442                        fn call(
4443                            &mut self,
4444                            request: tonic::Request<super::DropTableRequest>,
4445                        ) -> Self::Future {
4446                            let inner = Arc::clone(&self.0);
4447                            let fut = async move {
4448                                <T as DdlService>::drop_table(&inner, request).await
4449                            };
4450                            Box::pin(fut)
4451                        }
4452                    }
4453                    let accept_compression_encodings = self.accept_compression_encodings;
4454                    let send_compression_encodings = self.send_compression_encodings;
4455                    let max_decoding_message_size = self.max_decoding_message_size;
4456                    let max_encoding_message_size = self.max_encoding_message_size;
4457                    let inner = self.inner.clone();
4458                    let fut = async move {
4459                        let method = DropTableSvc(inner);
4460                        let codec = tonic_prost::ProstCodec::default();
4461                        let mut grpc = tonic::server::Grpc::new(codec)
4462                            .apply_compression_config(
4463                                accept_compression_encodings,
4464                                send_compression_encodings,
4465                            )
4466                            .apply_max_message_size_config(
4467                                max_decoding_message_size,
4468                                max_encoding_message_size,
4469                            );
4470                        let res = grpc.unary(method, req).await;
4471                        Ok(res)
4472                    };
4473                    Box::pin(fut)
4474                }
4475                "/ddl_service.DdlService/RisectlListStateTables" => {
4476                    #[allow(non_camel_case_types)]
4477                    struct RisectlListStateTablesSvc<T: DdlService>(pub Arc<T>);
4478                    impl<
4479                        T: DdlService,
4480                    > tonic::server::UnaryService<super::RisectlListStateTablesRequest>
4481                    for RisectlListStateTablesSvc<T> {
4482                        type Response = super::RisectlListStateTablesResponse;
4483                        type Future = BoxFuture<
4484                            tonic::Response<Self::Response>,
4485                            tonic::Status,
4486                        >;
4487                        fn call(
4488                            &mut self,
4489                            request: tonic::Request<super::RisectlListStateTablesRequest>,
4490                        ) -> Self::Future {
4491                            let inner = Arc::clone(&self.0);
4492                            let fut = async move {
4493                                <T as DdlService>::risectl_list_state_tables(
4494                                        &inner,
4495                                        request,
4496                                    )
4497                                    .await
4498                            };
4499                            Box::pin(fut)
4500                        }
4501                    }
4502                    let accept_compression_encodings = self.accept_compression_encodings;
4503                    let send_compression_encodings = self.send_compression_encodings;
4504                    let max_decoding_message_size = self.max_decoding_message_size;
4505                    let max_encoding_message_size = self.max_encoding_message_size;
4506                    let inner = self.inner.clone();
4507                    let fut = async move {
4508                        let method = RisectlListStateTablesSvc(inner);
4509                        let codec = tonic_prost::ProstCodec::default();
4510                        let mut grpc = tonic::server::Grpc::new(codec)
4511                            .apply_compression_config(
4512                                accept_compression_encodings,
4513                                send_compression_encodings,
4514                            )
4515                            .apply_max_message_size_config(
4516                                max_decoding_message_size,
4517                                max_encoding_message_size,
4518                            );
4519                        let res = grpc.unary(method, req).await;
4520                        Ok(res)
4521                    };
4522                    Box::pin(fut)
4523                }
4524                "/ddl_service.DdlService/RisectlResumeBackfill" => {
4525                    #[allow(non_camel_case_types)]
4526                    struct RisectlResumeBackfillSvc<T: DdlService>(pub Arc<T>);
4527                    impl<
4528                        T: DdlService,
4529                    > tonic::server::UnaryService<super::RisectlResumeBackfillRequest>
4530                    for RisectlResumeBackfillSvc<T> {
4531                        type Response = super::RisectlResumeBackfillResponse;
4532                        type Future = BoxFuture<
4533                            tonic::Response<Self::Response>,
4534                            tonic::Status,
4535                        >;
4536                        fn call(
4537                            &mut self,
4538                            request: tonic::Request<super::RisectlResumeBackfillRequest>,
4539                        ) -> Self::Future {
4540                            let inner = Arc::clone(&self.0);
4541                            let fut = async move {
4542                                <T as DdlService>::risectl_resume_backfill(&inner, request)
4543                                    .await
4544                            };
4545                            Box::pin(fut)
4546                        }
4547                    }
4548                    let accept_compression_encodings = self.accept_compression_encodings;
4549                    let send_compression_encodings = self.send_compression_encodings;
4550                    let max_decoding_message_size = self.max_decoding_message_size;
4551                    let max_encoding_message_size = self.max_encoding_message_size;
4552                    let inner = self.inner.clone();
4553                    let fut = async move {
4554                        let method = RisectlResumeBackfillSvc(inner);
4555                        let codec = tonic_prost::ProstCodec::default();
4556                        let mut grpc = tonic::server::Grpc::new(codec)
4557                            .apply_compression_config(
4558                                accept_compression_encodings,
4559                                send_compression_encodings,
4560                            )
4561                            .apply_max_message_size_config(
4562                                max_decoding_message_size,
4563                                max_encoding_message_size,
4564                            );
4565                        let res = grpc.unary(method, req).await;
4566                        Ok(res)
4567                    };
4568                    Box::pin(fut)
4569                }
4570                "/ddl_service.DdlService/CreateView" => {
4571                    #[allow(non_camel_case_types)]
4572                    struct CreateViewSvc<T: DdlService>(pub Arc<T>);
4573                    impl<
4574                        T: DdlService,
4575                    > tonic::server::UnaryService<super::CreateViewRequest>
4576                    for CreateViewSvc<T> {
4577                        type Response = super::CreateViewResponse;
4578                        type Future = BoxFuture<
4579                            tonic::Response<Self::Response>,
4580                            tonic::Status,
4581                        >;
4582                        fn call(
4583                            &mut self,
4584                            request: tonic::Request<super::CreateViewRequest>,
4585                        ) -> Self::Future {
4586                            let inner = Arc::clone(&self.0);
4587                            let fut = async move {
4588                                <T as DdlService>::create_view(&inner, request).await
4589                            };
4590                            Box::pin(fut)
4591                        }
4592                    }
4593                    let accept_compression_encodings = self.accept_compression_encodings;
4594                    let send_compression_encodings = self.send_compression_encodings;
4595                    let max_decoding_message_size = self.max_decoding_message_size;
4596                    let max_encoding_message_size = self.max_encoding_message_size;
4597                    let inner = self.inner.clone();
4598                    let fut = async move {
4599                        let method = CreateViewSvc(inner);
4600                        let codec = tonic_prost::ProstCodec::default();
4601                        let mut grpc = tonic::server::Grpc::new(codec)
4602                            .apply_compression_config(
4603                                accept_compression_encodings,
4604                                send_compression_encodings,
4605                            )
4606                            .apply_max_message_size_config(
4607                                max_decoding_message_size,
4608                                max_encoding_message_size,
4609                            );
4610                        let res = grpc.unary(method, req).await;
4611                        Ok(res)
4612                    };
4613                    Box::pin(fut)
4614                }
4615                "/ddl_service.DdlService/DropView" => {
4616                    #[allow(non_camel_case_types)]
4617                    struct DropViewSvc<T: DdlService>(pub Arc<T>);
4618                    impl<
4619                        T: DdlService,
4620                    > tonic::server::UnaryService<super::DropViewRequest>
4621                    for DropViewSvc<T> {
4622                        type Response = super::DropViewResponse;
4623                        type Future = BoxFuture<
4624                            tonic::Response<Self::Response>,
4625                            tonic::Status,
4626                        >;
4627                        fn call(
4628                            &mut self,
4629                            request: tonic::Request<super::DropViewRequest>,
4630                        ) -> Self::Future {
4631                            let inner = Arc::clone(&self.0);
4632                            let fut = async move {
4633                                <T as DdlService>::drop_view(&inner, request).await
4634                            };
4635                            Box::pin(fut)
4636                        }
4637                    }
4638                    let accept_compression_encodings = self.accept_compression_encodings;
4639                    let send_compression_encodings = self.send_compression_encodings;
4640                    let max_decoding_message_size = self.max_decoding_message_size;
4641                    let max_encoding_message_size = self.max_encoding_message_size;
4642                    let inner = self.inner.clone();
4643                    let fut = async move {
4644                        let method = DropViewSvc(inner);
4645                        let codec = tonic_prost::ProstCodec::default();
4646                        let mut grpc = tonic::server::Grpc::new(codec)
4647                            .apply_compression_config(
4648                                accept_compression_encodings,
4649                                send_compression_encodings,
4650                            )
4651                            .apply_max_message_size_config(
4652                                max_decoding_message_size,
4653                                max_encoding_message_size,
4654                            );
4655                        let res = grpc.unary(method, req).await;
4656                        Ok(res)
4657                    };
4658                    Box::pin(fut)
4659                }
4660                "/ddl_service.DdlService/CreateIndex" => {
4661                    #[allow(non_camel_case_types)]
4662                    struct CreateIndexSvc<T: DdlService>(pub Arc<T>);
4663                    impl<
4664                        T: DdlService,
4665                    > tonic::server::UnaryService<super::CreateIndexRequest>
4666                    for CreateIndexSvc<T> {
4667                        type Response = super::CreateIndexResponse;
4668                        type Future = BoxFuture<
4669                            tonic::Response<Self::Response>,
4670                            tonic::Status,
4671                        >;
4672                        fn call(
4673                            &mut self,
4674                            request: tonic::Request<super::CreateIndexRequest>,
4675                        ) -> Self::Future {
4676                            let inner = Arc::clone(&self.0);
4677                            let fut = async move {
4678                                <T as DdlService>::create_index(&inner, request).await
4679                            };
4680                            Box::pin(fut)
4681                        }
4682                    }
4683                    let accept_compression_encodings = self.accept_compression_encodings;
4684                    let send_compression_encodings = self.send_compression_encodings;
4685                    let max_decoding_message_size = self.max_decoding_message_size;
4686                    let max_encoding_message_size = self.max_encoding_message_size;
4687                    let inner = self.inner.clone();
4688                    let fut = async move {
4689                        let method = CreateIndexSvc(inner);
4690                        let codec = tonic_prost::ProstCodec::default();
4691                        let mut grpc = tonic::server::Grpc::new(codec)
4692                            .apply_compression_config(
4693                                accept_compression_encodings,
4694                                send_compression_encodings,
4695                            )
4696                            .apply_max_message_size_config(
4697                                max_decoding_message_size,
4698                                max_encoding_message_size,
4699                            );
4700                        let res = grpc.unary(method, req).await;
4701                        Ok(res)
4702                    };
4703                    Box::pin(fut)
4704                }
4705                "/ddl_service.DdlService/DropIndex" => {
4706                    #[allow(non_camel_case_types)]
4707                    struct DropIndexSvc<T: DdlService>(pub Arc<T>);
4708                    impl<
4709                        T: DdlService,
4710                    > tonic::server::UnaryService<super::DropIndexRequest>
4711                    for DropIndexSvc<T> {
4712                        type Response = super::DropIndexResponse;
4713                        type Future = BoxFuture<
4714                            tonic::Response<Self::Response>,
4715                            tonic::Status,
4716                        >;
4717                        fn call(
4718                            &mut self,
4719                            request: tonic::Request<super::DropIndexRequest>,
4720                        ) -> Self::Future {
4721                            let inner = Arc::clone(&self.0);
4722                            let fut = async move {
4723                                <T as DdlService>::drop_index(&inner, request).await
4724                            };
4725                            Box::pin(fut)
4726                        }
4727                    }
4728                    let accept_compression_encodings = self.accept_compression_encodings;
4729                    let send_compression_encodings = self.send_compression_encodings;
4730                    let max_decoding_message_size = self.max_decoding_message_size;
4731                    let max_encoding_message_size = self.max_encoding_message_size;
4732                    let inner = self.inner.clone();
4733                    let fut = async move {
4734                        let method = DropIndexSvc(inner);
4735                        let codec = tonic_prost::ProstCodec::default();
4736                        let mut grpc = tonic::server::Grpc::new(codec)
4737                            .apply_compression_config(
4738                                accept_compression_encodings,
4739                                send_compression_encodings,
4740                            )
4741                            .apply_max_message_size_config(
4742                                max_decoding_message_size,
4743                                max_encoding_message_size,
4744                            );
4745                        let res = grpc.unary(method, req).await;
4746                        Ok(res)
4747                    };
4748                    Box::pin(fut)
4749                }
4750                "/ddl_service.DdlService/CreateFunction" => {
4751                    #[allow(non_camel_case_types)]
4752                    struct CreateFunctionSvc<T: DdlService>(pub Arc<T>);
4753                    impl<
4754                        T: DdlService,
4755                    > tonic::server::UnaryService<super::CreateFunctionRequest>
4756                    for CreateFunctionSvc<T> {
4757                        type Response = super::CreateFunctionResponse;
4758                        type Future = BoxFuture<
4759                            tonic::Response<Self::Response>,
4760                            tonic::Status,
4761                        >;
4762                        fn call(
4763                            &mut self,
4764                            request: tonic::Request<super::CreateFunctionRequest>,
4765                        ) -> Self::Future {
4766                            let inner = Arc::clone(&self.0);
4767                            let fut = async move {
4768                                <T as DdlService>::create_function(&inner, request).await
4769                            };
4770                            Box::pin(fut)
4771                        }
4772                    }
4773                    let accept_compression_encodings = self.accept_compression_encodings;
4774                    let send_compression_encodings = self.send_compression_encodings;
4775                    let max_decoding_message_size = self.max_decoding_message_size;
4776                    let max_encoding_message_size = self.max_encoding_message_size;
4777                    let inner = self.inner.clone();
4778                    let fut = async move {
4779                        let method = CreateFunctionSvc(inner);
4780                        let codec = tonic_prost::ProstCodec::default();
4781                        let mut grpc = tonic::server::Grpc::new(codec)
4782                            .apply_compression_config(
4783                                accept_compression_encodings,
4784                                send_compression_encodings,
4785                            )
4786                            .apply_max_message_size_config(
4787                                max_decoding_message_size,
4788                                max_encoding_message_size,
4789                            );
4790                        let res = grpc.unary(method, req).await;
4791                        Ok(res)
4792                    };
4793                    Box::pin(fut)
4794                }
4795                "/ddl_service.DdlService/DropFunction" => {
4796                    #[allow(non_camel_case_types)]
4797                    struct DropFunctionSvc<T: DdlService>(pub Arc<T>);
4798                    impl<
4799                        T: DdlService,
4800                    > tonic::server::UnaryService<super::DropFunctionRequest>
4801                    for DropFunctionSvc<T> {
4802                        type Response = super::DropFunctionResponse;
4803                        type Future = BoxFuture<
4804                            tonic::Response<Self::Response>,
4805                            tonic::Status,
4806                        >;
4807                        fn call(
4808                            &mut self,
4809                            request: tonic::Request<super::DropFunctionRequest>,
4810                        ) -> Self::Future {
4811                            let inner = Arc::clone(&self.0);
4812                            let fut = async move {
4813                                <T as DdlService>::drop_function(&inner, request).await
4814                            };
4815                            Box::pin(fut)
4816                        }
4817                    }
4818                    let accept_compression_encodings = self.accept_compression_encodings;
4819                    let send_compression_encodings = self.send_compression_encodings;
4820                    let max_decoding_message_size = self.max_decoding_message_size;
4821                    let max_encoding_message_size = self.max_encoding_message_size;
4822                    let inner = self.inner.clone();
4823                    let fut = async move {
4824                        let method = DropFunctionSvc(inner);
4825                        let codec = tonic_prost::ProstCodec::default();
4826                        let mut grpc = tonic::server::Grpc::new(codec)
4827                            .apply_compression_config(
4828                                accept_compression_encodings,
4829                                send_compression_encodings,
4830                            )
4831                            .apply_max_message_size_config(
4832                                max_decoding_message_size,
4833                                max_encoding_message_size,
4834                            );
4835                        let res = grpc.unary(method, req).await;
4836                        Ok(res)
4837                    };
4838                    Box::pin(fut)
4839                }
4840                "/ddl_service.DdlService/ReplaceJobPlan" => {
4841                    #[allow(non_camel_case_types)]
4842                    struct ReplaceJobPlanSvc<T: DdlService>(pub Arc<T>);
4843                    impl<
4844                        T: DdlService,
4845                    > tonic::server::UnaryService<super::ReplaceJobPlanRequest>
4846                    for ReplaceJobPlanSvc<T> {
4847                        type Response = super::ReplaceJobPlanResponse;
4848                        type Future = BoxFuture<
4849                            tonic::Response<Self::Response>,
4850                            tonic::Status,
4851                        >;
4852                        fn call(
4853                            &mut self,
4854                            request: tonic::Request<super::ReplaceJobPlanRequest>,
4855                        ) -> Self::Future {
4856                            let inner = Arc::clone(&self.0);
4857                            let fut = async move {
4858                                <T as DdlService>::replace_job_plan(&inner, request).await
4859                            };
4860                            Box::pin(fut)
4861                        }
4862                    }
4863                    let accept_compression_encodings = self.accept_compression_encodings;
4864                    let send_compression_encodings = self.send_compression_encodings;
4865                    let max_decoding_message_size = self.max_decoding_message_size;
4866                    let max_encoding_message_size = self.max_encoding_message_size;
4867                    let inner = self.inner.clone();
4868                    let fut = async move {
4869                        let method = ReplaceJobPlanSvc(inner);
4870                        let codec = tonic_prost::ProstCodec::default();
4871                        let mut grpc = tonic::server::Grpc::new(codec)
4872                            .apply_compression_config(
4873                                accept_compression_encodings,
4874                                send_compression_encodings,
4875                            )
4876                            .apply_max_message_size_config(
4877                                max_decoding_message_size,
4878                                max_encoding_message_size,
4879                            );
4880                        let res = grpc.unary(method, req).await;
4881                        Ok(res)
4882                    };
4883                    Box::pin(fut)
4884                }
4885                "/ddl_service.DdlService/GetTable" => {
4886                    #[allow(non_camel_case_types)]
4887                    struct GetTableSvc<T: DdlService>(pub Arc<T>);
4888                    impl<
4889                        T: DdlService,
4890                    > tonic::server::UnaryService<super::GetTableRequest>
4891                    for GetTableSvc<T> {
4892                        type Response = super::GetTableResponse;
4893                        type Future = BoxFuture<
4894                            tonic::Response<Self::Response>,
4895                            tonic::Status,
4896                        >;
4897                        fn call(
4898                            &mut self,
4899                            request: tonic::Request<super::GetTableRequest>,
4900                        ) -> Self::Future {
4901                            let inner = Arc::clone(&self.0);
4902                            let fut = async move {
4903                                <T as DdlService>::get_table(&inner, request).await
4904                            };
4905                            Box::pin(fut)
4906                        }
4907                    }
4908                    let accept_compression_encodings = self.accept_compression_encodings;
4909                    let send_compression_encodings = self.send_compression_encodings;
4910                    let max_decoding_message_size = self.max_decoding_message_size;
4911                    let max_encoding_message_size = self.max_encoding_message_size;
4912                    let inner = self.inner.clone();
4913                    let fut = async move {
4914                        let method = GetTableSvc(inner);
4915                        let codec = tonic_prost::ProstCodec::default();
4916                        let mut grpc = tonic::server::Grpc::new(codec)
4917                            .apply_compression_config(
4918                                accept_compression_encodings,
4919                                send_compression_encodings,
4920                            )
4921                            .apply_max_message_size_config(
4922                                max_decoding_message_size,
4923                                max_encoding_message_size,
4924                            );
4925                        let res = grpc.unary(method, req).await;
4926                        Ok(res)
4927                    };
4928                    Box::pin(fut)
4929                }
4930                "/ddl_service.DdlService/GetDdlProgress" => {
4931                    #[allow(non_camel_case_types)]
4932                    struct GetDdlProgressSvc<T: DdlService>(pub Arc<T>);
4933                    impl<
4934                        T: DdlService,
4935                    > tonic::server::UnaryService<super::GetDdlProgressRequest>
4936                    for GetDdlProgressSvc<T> {
4937                        type Response = super::GetDdlProgressResponse;
4938                        type Future = BoxFuture<
4939                            tonic::Response<Self::Response>,
4940                            tonic::Status,
4941                        >;
4942                        fn call(
4943                            &mut self,
4944                            request: tonic::Request<super::GetDdlProgressRequest>,
4945                        ) -> Self::Future {
4946                            let inner = Arc::clone(&self.0);
4947                            let fut = async move {
4948                                <T as DdlService>::get_ddl_progress(&inner, request).await
4949                            };
4950                            Box::pin(fut)
4951                        }
4952                    }
4953                    let accept_compression_encodings = self.accept_compression_encodings;
4954                    let send_compression_encodings = self.send_compression_encodings;
4955                    let max_decoding_message_size = self.max_decoding_message_size;
4956                    let max_encoding_message_size = self.max_encoding_message_size;
4957                    let inner = self.inner.clone();
4958                    let fut = async move {
4959                        let method = GetDdlProgressSvc(inner);
4960                        let codec = tonic_prost::ProstCodec::default();
4961                        let mut grpc = tonic::server::Grpc::new(codec)
4962                            .apply_compression_config(
4963                                accept_compression_encodings,
4964                                send_compression_encodings,
4965                            )
4966                            .apply_max_message_size_config(
4967                                max_decoding_message_size,
4968                                max_encoding_message_size,
4969                            );
4970                        let res = grpc.unary(method, req).await;
4971                        Ok(res)
4972                    };
4973                    Box::pin(fut)
4974                }
4975                "/ddl_service.DdlService/CreateConnection" => {
4976                    #[allow(non_camel_case_types)]
4977                    struct CreateConnectionSvc<T: DdlService>(pub Arc<T>);
4978                    impl<
4979                        T: DdlService,
4980                    > tonic::server::UnaryService<super::CreateConnectionRequest>
4981                    for CreateConnectionSvc<T> {
4982                        type Response = super::CreateConnectionResponse;
4983                        type Future = BoxFuture<
4984                            tonic::Response<Self::Response>,
4985                            tonic::Status,
4986                        >;
4987                        fn call(
4988                            &mut self,
4989                            request: tonic::Request<super::CreateConnectionRequest>,
4990                        ) -> Self::Future {
4991                            let inner = Arc::clone(&self.0);
4992                            let fut = async move {
4993                                <T as DdlService>::create_connection(&inner, request).await
4994                            };
4995                            Box::pin(fut)
4996                        }
4997                    }
4998                    let accept_compression_encodings = self.accept_compression_encodings;
4999                    let send_compression_encodings = self.send_compression_encodings;
5000                    let max_decoding_message_size = self.max_decoding_message_size;
5001                    let max_encoding_message_size = self.max_encoding_message_size;
5002                    let inner = self.inner.clone();
5003                    let fut = async move {
5004                        let method = CreateConnectionSvc(inner);
5005                        let codec = tonic_prost::ProstCodec::default();
5006                        let mut grpc = tonic::server::Grpc::new(codec)
5007                            .apply_compression_config(
5008                                accept_compression_encodings,
5009                                send_compression_encodings,
5010                            )
5011                            .apply_max_message_size_config(
5012                                max_decoding_message_size,
5013                                max_encoding_message_size,
5014                            );
5015                        let res = grpc.unary(method, req).await;
5016                        Ok(res)
5017                    };
5018                    Box::pin(fut)
5019                }
5020                "/ddl_service.DdlService/ListConnections" => {
5021                    #[allow(non_camel_case_types)]
5022                    struct ListConnectionsSvc<T: DdlService>(pub Arc<T>);
5023                    impl<
5024                        T: DdlService,
5025                    > tonic::server::UnaryService<super::ListConnectionsRequest>
5026                    for ListConnectionsSvc<T> {
5027                        type Response = super::ListConnectionsResponse;
5028                        type Future = BoxFuture<
5029                            tonic::Response<Self::Response>,
5030                            tonic::Status,
5031                        >;
5032                        fn call(
5033                            &mut self,
5034                            request: tonic::Request<super::ListConnectionsRequest>,
5035                        ) -> Self::Future {
5036                            let inner = Arc::clone(&self.0);
5037                            let fut = async move {
5038                                <T as DdlService>::list_connections(&inner, request).await
5039                            };
5040                            Box::pin(fut)
5041                        }
5042                    }
5043                    let accept_compression_encodings = self.accept_compression_encodings;
5044                    let send_compression_encodings = self.send_compression_encodings;
5045                    let max_decoding_message_size = self.max_decoding_message_size;
5046                    let max_encoding_message_size = self.max_encoding_message_size;
5047                    let inner = self.inner.clone();
5048                    let fut = async move {
5049                        let method = ListConnectionsSvc(inner);
5050                        let codec = tonic_prost::ProstCodec::default();
5051                        let mut grpc = tonic::server::Grpc::new(codec)
5052                            .apply_compression_config(
5053                                accept_compression_encodings,
5054                                send_compression_encodings,
5055                            )
5056                            .apply_max_message_size_config(
5057                                max_decoding_message_size,
5058                                max_encoding_message_size,
5059                            );
5060                        let res = grpc.unary(method, req).await;
5061                        Ok(res)
5062                    };
5063                    Box::pin(fut)
5064                }
5065                "/ddl_service.DdlService/DropConnection" => {
5066                    #[allow(non_camel_case_types)]
5067                    struct DropConnectionSvc<T: DdlService>(pub Arc<T>);
5068                    impl<
5069                        T: DdlService,
5070                    > tonic::server::UnaryService<super::DropConnectionRequest>
5071                    for DropConnectionSvc<T> {
5072                        type Response = super::DropConnectionResponse;
5073                        type Future = BoxFuture<
5074                            tonic::Response<Self::Response>,
5075                            tonic::Status,
5076                        >;
5077                        fn call(
5078                            &mut self,
5079                            request: tonic::Request<super::DropConnectionRequest>,
5080                        ) -> Self::Future {
5081                            let inner = Arc::clone(&self.0);
5082                            let fut = async move {
5083                                <T as DdlService>::drop_connection(&inner, request).await
5084                            };
5085                            Box::pin(fut)
5086                        }
5087                    }
5088                    let accept_compression_encodings = self.accept_compression_encodings;
5089                    let send_compression_encodings = self.send_compression_encodings;
5090                    let max_decoding_message_size = self.max_decoding_message_size;
5091                    let max_encoding_message_size = self.max_encoding_message_size;
5092                    let inner = self.inner.clone();
5093                    let fut = async move {
5094                        let method = DropConnectionSvc(inner);
5095                        let codec = tonic_prost::ProstCodec::default();
5096                        let mut grpc = tonic::server::Grpc::new(codec)
5097                            .apply_compression_config(
5098                                accept_compression_encodings,
5099                                send_compression_encodings,
5100                            )
5101                            .apply_max_message_size_config(
5102                                max_decoding_message_size,
5103                                max_encoding_message_size,
5104                            );
5105                        let res = grpc.unary(method, req).await;
5106                        Ok(res)
5107                    };
5108                    Box::pin(fut)
5109                }
5110                "/ddl_service.DdlService/GetTables" => {
5111                    #[allow(non_camel_case_types)]
5112                    struct GetTablesSvc<T: DdlService>(pub Arc<T>);
5113                    impl<
5114                        T: DdlService,
5115                    > tonic::server::UnaryService<super::GetTablesRequest>
5116                    for GetTablesSvc<T> {
5117                        type Response = super::GetTablesResponse;
5118                        type Future = BoxFuture<
5119                            tonic::Response<Self::Response>,
5120                            tonic::Status,
5121                        >;
5122                        fn call(
5123                            &mut self,
5124                            request: tonic::Request<super::GetTablesRequest>,
5125                        ) -> Self::Future {
5126                            let inner = Arc::clone(&self.0);
5127                            let fut = async move {
5128                                <T as DdlService>::get_tables(&inner, request).await
5129                            };
5130                            Box::pin(fut)
5131                        }
5132                    }
5133                    let accept_compression_encodings = self.accept_compression_encodings;
5134                    let send_compression_encodings = self.send_compression_encodings;
5135                    let max_decoding_message_size = self.max_decoding_message_size;
5136                    let max_encoding_message_size = self.max_encoding_message_size;
5137                    let inner = self.inner.clone();
5138                    let fut = async move {
5139                        let method = GetTablesSvc(inner);
5140                        let codec = tonic_prost::ProstCodec::default();
5141                        let mut grpc = tonic::server::Grpc::new(codec)
5142                            .apply_compression_config(
5143                                accept_compression_encodings,
5144                                send_compression_encodings,
5145                            )
5146                            .apply_max_message_size_config(
5147                                max_decoding_message_size,
5148                                max_encoding_message_size,
5149                            );
5150                        let res = grpc.unary(method, req).await;
5151                        Ok(res)
5152                    };
5153                    Box::pin(fut)
5154                }
5155                "/ddl_service.DdlService/Wait" => {
5156                    #[allow(non_camel_case_types)]
5157                    struct WaitSvc<T: DdlService>(pub Arc<T>);
5158                    impl<T: DdlService> tonic::server::UnaryService<super::WaitRequest>
5159                    for WaitSvc<T> {
5160                        type Response = super::WaitResponse;
5161                        type Future = BoxFuture<
5162                            tonic::Response<Self::Response>,
5163                            tonic::Status,
5164                        >;
5165                        fn call(
5166                            &mut self,
5167                            request: tonic::Request<super::WaitRequest>,
5168                        ) -> Self::Future {
5169                            let inner = Arc::clone(&self.0);
5170                            let fut = async move {
5171                                <T as DdlService>::wait(&inner, request).await
5172                            };
5173                            Box::pin(fut)
5174                        }
5175                    }
5176                    let accept_compression_encodings = self.accept_compression_encodings;
5177                    let send_compression_encodings = self.send_compression_encodings;
5178                    let max_decoding_message_size = self.max_decoding_message_size;
5179                    let max_encoding_message_size = self.max_encoding_message_size;
5180                    let inner = self.inner.clone();
5181                    let fut = async move {
5182                        let method = WaitSvc(inner);
5183                        let codec = tonic_prost::ProstCodec::default();
5184                        let mut grpc = tonic::server::Grpc::new(codec)
5185                            .apply_compression_config(
5186                                accept_compression_encodings,
5187                                send_compression_encodings,
5188                            )
5189                            .apply_max_message_size_config(
5190                                max_decoding_message_size,
5191                                max_encoding_message_size,
5192                            );
5193                        let res = grpc.unary(method, req).await;
5194                        Ok(res)
5195                    };
5196                    Box::pin(fut)
5197                }
5198                "/ddl_service.DdlService/CommentOn" => {
5199                    #[allow(non_camel_case_types)]
5200                    struct CommentOnSvc<T: DdlService>(pub Arc<T>);
5201                    impl<
5202                        T: DdlService,
5203                    > tonic::server::UnaryService<super::CommentOnRequest>
5204                    for CommentOnSvc<T> {
5205                        type Response = super::CommentOnResponse;
5206                        type Future = BoxFuture<
5207                            tonic::Response<Self::Response>,
5208                            tonic::Status,
5209                        >;
5210                        fn call(
5211                            &mut self,
5212                            request: tonic::Request<super::CommentOnRequest>,
5213                        ) -> Self::Future {
5214                            let inner = Arc::clone(&self.0);
5215                            let fut = async move {
5216                                <T as DdlService>::comment_on(&inner, request).await
5217                            };
5218                            Box::pin(fut)
5219                        }
5220                    }
5221                    let accept_compression_encodings = self.accept_compression_encodings;
5222                    let send_compression_encodings = self.send_compression_encodings;
5223                    let max_decoding_message_size = self.max_decoding_message_size;
5224                    let max_encoding_message_size = self.max_encoding_message_size;
5225                    let inner = self.inner.clone();
5226                    let fut = async move {
5227                        let method = CommentOnSvc(inner);
5228                        let codec = tonic_prost::ProstCodec::default();
5229                        let mut grpc = tonic::server::Grpc::new(codec)
5230                            .apply_compression_config(
5231                                accept_compression_encodings,
5232                                send_compression_encodings,
5233                            )
5234                            .apply_max_message_size_config(
5235                                max_decoding_message_size,
5236                                max_encoding_message_size,
5237                            );
5238                        let res = grpc.unary(method, req).await;
5239                        Ok(res)
5240                    };
5241                    Box::pin(fut)
5242                }
5243                "/ddl_service.DdlService/AutoSchemaChange" => {
5244                    #[allow(non_camel_case_types)]
5245                    struct AutoSchemaChangeSvc<T: DdlService>(pub Arc<T>);
5246                    impl<
5247                        T: DdlService,
5248                    > tonic::server::UnaryService<super::AutoSchemaChangeRequest>
5249                    for AutoSchemaChangeSvc<T> {
5250                        type Response = super::AutoSchemaChangeResponse;
5251                        type Future = BoxFuture<
5252                            tonic::Response<Self::Response>,
5253                            tonic::Status,
5254                        >;
5255                        fn call(
5256                            &mut self,
5257                            request: tonic::Request<super::AutoSchemaChangeRequest>,
5258                        ) -> Self::Future {
5259                            let inner = Arc::clone(&self.0);
5260                            let fut = async move {
5261                                <T as DdlService>::auto_schema_change(&inner, request).await
5262                            };
5263                            Box::pin(fut)
5264                        }
5265                    }
5266                    let accept_compression_encodings = self.accept_compression_encodings;
5267                    let send_compression_encodings = self.send_compression_encodings;
5268                    let max_decoding_message_size = self.max_decoding_message_size;
5269                    let max_encoding_message_size = self.max_encoding_message_size;
5270                    let inner = self.inner.clone();
5271                    let fut = async move {
5272                        let method = AutoSchemaChangeSvc(inner);
5273                        let codec = tonic_prost::ProstCodec::default();
5274                        let mut grpc = tonic::server::Grpc::new(codec)
5275                            .apply_compression_config(
5276                                accept_compression_encodings,
5277                                send_compression_encodings,
5278                            )
5279                            .apply_max_message_size_config(
5280                                max_decoding_message_size,
5281                                max_encoding_message_size,
5282                            );
5283                        let res = grpc.unary(method, req).await;
5284                        Ok(res)
5285                    };
5286                    Box::pin(fut)
5287                }
5288                "/ddl_service.DdlService/AlterSwapRename" => {
5289                    #[allow(non_camel_case_types)]
5290                    struct AlterSwapRenameSvc<T: DdlService>(pub Arc<T>);
5291                    impl<
5292                        T: DdlService,
5293                    > tonic::server::UnaryService<super::AlterSwapRenameRequest>
5294                    for AlterSwapRenameSvc<T> {
5295                        type Response = super::AlterSwapRenameResponse;
5296                        type Future = BoxFuture<
5297                            tonic::Response<Self::Response>,
5298                            tonic::Status,
5299                        >;
5300                        fn call(
5301                            &mut self,
5302                            request: tonic::Request<super::AlterSwapRenameRequest>,
5303                        ) -> Self::Future {
5304                            let inner = Arc::clone(&self.0);
5305                            let fut = async move {
5306                                <T as DdlService>::alter_swap_rename(&inner, request).await
5307                            };
5308                            Box::pin(fut)
5309                        }
5310                    }
5311                    let accept_compression_encodings = self.accept_compression_encodings;
5312                    let send_compression_encodings = self.send_compression_encodings;
5313                    let max_decoding_message_size = self.max_decoding_message_size;
5314                    let max_encoding_message_size = self.max_encoding_message_size;
5315                    let inner = self.inner.clone();
5316                    let fut = async move {
5317                        let method = AlterSwapRenameSvc(inner);
5318                        let codec = tonic_prost::ProstCodec::default();
5319                        let mut grpc = tonic::server::Grpc::new(codec)
5320                            .apply_compression_config(
5321                                accept_compression_encodings,
5322                                send_compression_encodings,
5323                            )
5324                            .apply_max_message_size_config(
5325                                max_decoding_message_size,
5326                                max_encoding_message_size,
5327                            );
5328                        let res = grpc.unary(method, req).await;
5329                        Ok(res)
5330                    };
5331                    Box::pin(fut)
5332                }
5333                "/ddl_service.DdlService/AlterDatabaseParam" => {
5334                    #[allow(non_camel_case_types)]
5335                    struct AlterDatabaseParamSvc<T: DdlService>(pub Arc<T>);
5336                    impl<
5337                        T: DdlService,
5338                    > tonic::server::UnaryService<super::AlterDatabaseParamRequest>
5339                    for AlterDatabaseParamSvc<T> {
5340                        type Response = super::AlterDatabaseParamResponse;
5341                        type Future = BoxFuture<
5342                            tonic::Response<Self::Response>,
5343                            tonic::Status,
5344                        >;
5345                        fn call(
5346                            &mut self,
5347                            request: tonic::Request<super::AlterDatabaseParamRequest>,
5348                        ) -> Self::Future {
5349                            let inner = Arc::clone(&self.0);
5350                            let fut = async move {
5351                                <T as DdlService>::alter_database_param(&inner, request)
5352                                    .await
5353                            };
5354                            Box::pin(fut)
5355                        }
5356                    }
5357                    let accept_compression_encodings = self.accept_compression_encodings;
5358                    let send_compression_encodings = self.send_compression_encodings;
5359                    let max_decoding_message_size = self.max_decoding_message_size;
5360                    let max_encoding_message_size = self.max_encoding_message_size;
5361                    let inner = self.inner.clone();
5362                    let fut = async move {
5363                        let method = AlterDatabaseParamSvc(inner);
5364                        let codec = tonic_prost::ProstCodec::default();
5365                        let mut grpc = tonic::server::Grpc::new(codec)
5366                            .apply_compression_config(
5367                                accept_compression_encodings,
5368                                send_compression_encodings,
5369                            )
5370                            .apply_max_message_size_config(
5371                                max_decoding_message_size,
5372                                max_encoding_message_size,
5373                            );
5374                        let res = grpc.unary(method, req).await;
5375                        Ok(res)
5376                    };
5377                    Box::pin(fut)
5378                }
5379                "/ddl_service.DdlService/CompactIcebergTable" => {
5380                    #[allow(non_camel_case_types)]
5381                    struct CompactIcebergTableSvc<T: DdlService>(pub Arc<T>);
5382                    impl<
5383                        T: DdlService,
5384                    > tonic::server::UnaryService<super::CompactIcebergTableRequest>
5385                    for CompactIcebergTableSvc<T> {
5386                        type Response = super::CompactIcebergTableResponse;
5387                        type Future = BoxFuture<
5388                            tonic::Response<Self::Response>,
5389                            tonic::Status,
5390                        >;
5391                        fn call(
5392                            &mut self,
5393                            request: tonic::Request<super::CompactIcebergTableRequest>,
5394                        ) -> Self::Future {
5395                            let inner = Arc::clone(&self.0);
5396                            let fut = async move {
5397                                <T as DdlService>::compact_iceberg_table(&inner, request)
5398                                    .await
5399                            };
5400                            Box::pin(fut)
5401                        }
5402                    }
5403                    let accept_compression_encodings = self.accept_compression_encodings;
5404                    let send_compression_encodings = self.send_compression_encodings;
5405                    let max_decoding_message_size = self.max_decoding_message_size;
5406                    let max_encoding_message_size = self.max_encoding_message_size;
5407                    let inner = self.inner.clone();
5408                    let fut = async move {
5409                        let method = CompactIcebergTableSvc(inner);
5410                        let codec = tonic_prost::ProstCodec::default();
5411                        let mut grpc = tonic::server::Grpc::new(codec)
5412                            .apply_compression_config(
5413                                accept_compression_encodings,
5414                                send_compression_encodings,
5415                            )
5416                            .apply_max_message_size_config(
5417                                max_decoding_message_size,
5418                                max_encoding_message_size,
5419                            );
5420                        let res = grpc.unary(method, req).await;
5421                        Ok(res)
5422                    };
5423                    Box::pin(fut)
5424                }
5425                "/ddl_service.DdlService/ExpireIcebergTableSnapshots" => {
5426                    #[allow(non_camel_case_types)]
5427                    struct ExpireIcebergTableSnapshotsSvc<T: DdlService>(pub Arc<T>);
5428                    impl<
5429                        T: DdlService,
5430                    > tonic::server::UnaryService<
5431                        super::ExpireIcebergTableSnapshotsRequest,
5432                    > for ExpireIcebergTableSnapshotsSvc<T> {
5433                        type Response = super::ExpireIcebergTableSnapshotsResponse;
5434                        type Future = BoxFuture<
5435                            tonic::Response<Self::Response>,
5436                            tonic::Status,
5437                        >;
5438                        fn call(
5439                            &mut self,
5440                            request: tonic::Request<
5441                                super::ExpireIcebergTableSnapshotsRequest,
5442                            >,
5443                        ) -> Self::Future {
5444                            let inner = Arc::clone(&self.0);
5445                            let fut = async move {
5446                                <T as DdlService>::expire_iceberg_table_snapshots(
5447                                        &inner,
5448                                        request,
5449                                    )
5450                                    .await
5451                            };
5452                            Box::pin(fut)
5453                        }
5454                    }
5455                    let accept_compression_encodings = self.accept_compression_encodings;
5456                    let send_compression_encodings = self.send_compression_encodings;
5457                    let max_decoding_message_size = self.max_decoding_message_size;
5458                    let max_encoding_message_size = self.max_encoding_message_size;
5459                    let inner = self.inner.clone();
5460                    let fut = async move {
5461                        let method = ExpireIcebergTableSnapshotsSvc(inner);
5462                        let codec = tonic_prost::ProstCodec::default();
5463                        let mut grpc = tonic::server::Grpc::new(codec)
5464                            .apply_compression_config(
5465                                accept_compression_encodings,
5466                                send_compression_encodings,
5467                            )
5468                            .apply_max_message_size_config(
5469                                max_decoding_message_size,
5470                                max_encoding_message_size,
5471                            );
5472                        let res = grpc.unary(method, req).await;
5473                        Ok(res)
5474                    };
5475                    Box::pin(fut)
5476                }
5477                "/ddl_service.DdlService/AlterCdcTableBackfillParallelism" => {
5478                    #[allow(non_camel_case_types)]
5479                    struct AlterCdcTableBackfillParallelismSvc<T: DdlService>(
5480                        pub Arc<T>,
5481                    );
5482                    impl<
5483                        T: DdlService,
5484                    > tonic::server::UnaryService<
5485                        super::AlterCdcTableBackfillParallelismRequest,
5486                    > for AlterCdcTableBackfillParallelismSvc<T> {
5487                        type Response = super::AlterCdcTableBackfillParallelismResponse;
5488                        type Future = BoxFuture<
5489                            tonic::Response<Self::Response>,
5490                            tonic::Status,
5491                        >;
5492                        fn call(
5493                            &mut self,
5494                            request: tonic::Request<
5495                                super::AlterCdcTableBackfillParallelismRequest,
5496                            >,
5497                        ) -> Self::Future {
5498                            let inner = Arc::clone(&self.0);
5499                            let fut = async move {
5500                                <T as DdlService>::alter_cdc_table_backfill_parallelism(
5501                                        &inner,
5502                                        request,
5503                                    )
5504                                    .await
5505                            };
5506                            Box::pin(fut)
5507                        }
5508                    }
5509                    let accept_compression_encodings = self.accept_compression_encodings;
5510                    let send_compression_encodings = self.send_compression_encodings;
5511                    let max_decoding_message_size = self.max_decoding_message_size;
5512                    let max_encoding_message_size = self.max_encoding_message_size;
5513                    let inner = self.inner.clone();
5514                    let fut = async move {
5515                        let method = AlterCdcTableBackfillParallelismSvc(inner);
5516                        let codec = tonic_prost::ProstCodec::default();
5517                        let mut grpc = tonic::server::Grpc::new(codec)
5518                            .apply_compression_config(
5519                                accept_compression_encodings,
5520                                send_compression_encodings,
5521                            )
5522                            .apply_max_message_size_config(
5523                                max_decoding_message_size,
5524                                max_encoding_message_size,
5525                            );
5526                        let res = grpc.unary(method, req).await;
5527                        Ok(res)
5528                    };
5529                    Box::pin(fut)
5530                }
5531                "/ddl_service.DdlService/AlterStreamingJobConfig" => {
5532                    #[allow(non_camel_case_types)]
5533                    struct AlterStreamingJobConfigSvc<T: DdlService>(pub Arc<T>);
5534                    impl<
5535                        T: DdlService,
5536                    > tonic::server::UnaryService<super::AlterStreamingJobConfigRequest>
5537                    for AlterStreamingJobConfigSvc<T> {
5538                        type Response = super::AlterStreamingJobConfigResponse;
5539                        type Future = BoxFuture<
5540                            tonic::Response<Self::Response>,
5541                            tonic::Status,
5542                        >;
5543                        fn call(
5544                            &mut self,
5545                            request: tonic::Request<
5546                                super::AlterStreamingJobConfigRequest,
5547                            >,
5548                        ) -> Self::Future {
5549                            let inner = Arc::clone(&self.0);
5550                            let fut = async move {
5551                                <T as DdlService>::alter_streaming_job_config(
5552                                        &inner,
5553                                        request,
5554                                    )
5555                                    .await
5556                            };
5557                            Box::pin(fut)
5558                        }
5559                    }
5560                    let accept_compression_encodings = self.accept_compression_encodings;
5561                    let send_compression_encodings = self.send_compression_encodings;
5562                    let max_decoding_message_size = self.max_decoding_message_size;
5563                    let max_encoding_message_size = self.max_encoding_message_size;
5564                    let inner = self.inner.clone();
5565                    let fut = async move {
5566                        let method = AlterStreamingJobConfigSvc(inner);
5567                        let codec = tonic_prost::ProstCodec::default();
5568                        let mut grpc = tonic::server::Grpc::new(codec)
5569                            .apply_compression_config(
5570                                accept_compression_encodings,
5571                                send_compression_encodings,
5572                            )
5573                            .apply_max_message_size_config(
5574                                max_decoding_message_size,
5575                                max_encoding_message_size,
5576                            );
5577                        let res = grpc.unary(method, req).await;
5578                        Ok(res)
5579                    };
5580                    Box::pin(fut)
5581                }
5582                _ => {
5583                    Box::pin(async move {
5584                        let mut response = http::Response::new(
5585                            tonic::body::Body::default(),
5586                        );
5587                        let headers = response.headers_mut();
5588                        headers
5589                            .insert(
5590                                tonic::Status::GRPC_STATUS,
5591                                (tonic::Code::Unimplemented as i32).into(),
5592                            );
5593                        headers
5594                            .insert(
5595                                http::header::CONTENT_TYPE,
5596                                tonic::metadata::GRPC_CONTENT_TYPE,
5597                            );
5598                        Ok(response)
5599                    })
5600                }
5601            }
5602        }
5603    }
5604    impl<T> Clone for DdlServiceServer<T> {
5605        fn clone(&self) -> Self {
5606            let inner = self.inner.clone();
5607            Self {
5608                inner,
5609                accept_compression_encodings: self.accept_compression_encodings,
5610                send_compression_encodings: self.send_compression_encodings,
5611                max_decoding_message_size: self.max_decoding_message_size,
5612                max_encoding_message_size: self.max_encoding_message_size,
5613            }
5614        }
5615    }
5616    /// Generated gRPC service name
5617    pub const SERVICE_NAME: &str = "ddl_service.DdlService";
5618    impl<T> tonic::server::NamedService for DdlServiceServer<T> {
5619        const NAME: &'static str = SERVICE_NAME;
5620    }
5621}
risingwave_pb/ddl_service.rs

risingwave_pb/
ddl_service.rs
