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