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