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