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