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