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