1#![allow(clippy::useless_conversion)]
2use crate::ddl_service::*;
3impl serde::Serialize for AlterBackfillParallelismRequest {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.table_id != 0 {
12 len += 1;
13 }
14 if self.parallelism.is_some() {
15 len += 1;
16 }
17 if self.deferred {
18 len += 1;
19 }
20 if self.adaptive_parallelism_strategy.is_some() {
21 len += 1;
22 }
23 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismRequest", len)?;
24 if self.table_id != 0 {
25 struct_ser.serialize_field("tableId", &self.table_id)?;
26 }
27 if let Some(v) = self.parallelism.as_ref() {
28 struct_ser.serialize_field("parallelism", v)?;
29 }
30 if self.deferred {
31 struct_ser.serialize_field("deferred", &self.deferred)?;
32 }
33 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
34 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
35 }
36 struct_ser.end()
37 }
38}
39impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismRequest {
40 #[allow(deprecated)]
41 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
42 where
43 D: serde::Deserializer<'de>,
44 {
45 const FIELDS: &[&str] = &[
46 "table_id",
47 "tableId",
48 "parallelism",
49 "deferred",
50 "adaptive_parallelism_strategy",
51 "adaptiveParallelismStrategy",
52 ];
53
54 #[allow(clippy::enum_variant_names)]
55 enum GeneratedField {
56 TableId,
57 Parallelism,
58 Deferred,
59 AdaptiveParallelismStrategy,
60 }
61 impl<'de> serde::Deserialize<'de> for GeneratedField {
62 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
63 where
64 D: serde::Deserializer<'de>,
65 {
66 struct GeneratedVisitor;
67
68 impl serde::de::Visitor<'_> for GeneratedVisitor {
69 type Value = GeneratedField;
70
71 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
72 write!(formatter, "expected one of: {:?}", &FIELDS)
73 }
74
75 #[allow(unused_variables)]
76 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
77 where
78 E: serde::de::Error,
79 {
80 match value {
81 "tableId" | "table_id" => Ok(GeneratedField::TableId),
82 "parallelism" => Ok(GeneratedField::Parallelism),
83 "deferred" => Ok(GeneratedField::Deferred),
84 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
85 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
86 }
87 }
88 }
89 deserializer.deserialize_identifier(GeneratedVisitor)
90 }
91 }
92 struct GeneratedVisitor;
93 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
94 type Value = AlterBackfillParallelismRequest;
95
96 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
97 formatter.write_str("struct ddl_service.AlterBackfillParallelismRequest")
98 }
99
100 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismRequest, V::Error>
101 where
102 V: serde::de::MapAccess<'de>,
103 {
104 let mut table_id__ = None;
105 let mut parallelism__ = None;
106 let mut deferred__ = None;
107 let mut adaptive_parallelism_strategy__ = None;
108 while let Some(k) = map_.next_key()? {
109 match k {
110 GeneratedField::TableId => {
111 if table_id__.is_some() {
112 return Err(serde::de::Error::duplicate_field("tableId"));
113 }
114 table_id__ =
115 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
116 ;
117 }
118 GeneratedField::Parallelism => {
119 if parallelism__.is_some() {
120 return Err(serde::de::Error::duplicate_field("parallelism"));
121 }
122 parallelism__ = map_.next_value()?;
123 }
124 GeneratedField::Deferred => {
125 if deferred__.is_some() {
126 return Err(serde::de::Error::duplicate_field("deferred"));
127 }
128 deferred__ = Some(map_.next_value()?);
129 }
130 GeneratedField::AdaptiveParallelismStrategy => {
131 if adaptive_parallelism_strategy__.is_some() {
132 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
133 }
134 adaptive_parallelism_strategy__ = map_.next_value()?;
135 }
136 }
137 }
138 Ok(AlterBackfillParallelismRequest {
139 table_id: table_id__.unwrap_or_default(),
140 parallelism: parallelism__,
141 deferred: deferred__.unwrap_or_default(),
142 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
143 })
144 }
145 }
146 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismRequest", FIELDS, GeneratedVisitor)
147 }
148}
149impl serde::Serialize for AlterBackfillParallelismResponse {
150 #[allow(deprecated)]
151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
152 where
153 S: serde::Serializer,
154 {
155 use serde::ser::SerializeStruct;
156 let len = 0;
157 let struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismResponse", len)?;
158 struct_ser.end()
159 }
160}
161impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismResponse {
162 #[allow(deprecated)]
163 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
164 where
165 D: serde::Deserializer<'de>,
166 {
167 const FIELDS: &[&str] = &[
168 ];
169
170 #[allow(clippy::enum_variant_names)]
171 enum GeneratedField {
172 }
173 impl<'de> serde::Deserialize<'de> for GeneratedField {
174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
175 where
176 D: serde::Deserializer<'de>,
177 {
178 struct GeneratedVisitor;
179
180 impl serde::de::Visitor<'_> for GeneratedVisitor {
181 type Value = GeneratedField;
182
183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
184 write!(formatter, "expected one of: {:?}", &FIELDS)
185 }
186
187 #[allow(unused_variables)]
188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
189 where
190 E: serde::de::Error,
191 {
192 Err(serde::de::Error::unknown_field(value, FIELDS))
193 }
194 }
195 deserializer.deserialize_identifier(GeneratedVisitor)
196 }
197 }
198 struct GeneratedVisitor;
199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
200 type Value = AlterBackfillParallelismResponse;
201
202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
203 formatter.write_str("struct ddl_service.AlterBackfillParallelismResponse")
204 }
205
206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismResponse, V::Error>
207 where
208 V: serde::de::MapAccess<'de>,
209 {
210 while map_.next_key::<GeneratedField>()?.is_some() {
211 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
212 }
213 Ok(AlterBackfillParallelismResponse {
214 })
215 }
216 }
217 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismResponse", FIELDS, GeneratedVisitor)
218 }
219}
220impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
221 #[allow(deprecated)]
222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
223 where
224 S: serde::Serializer,
225 {
226 use serde::ser::SerializeStruct;
227 let mut len = 0;
228 if self.table_id != 0 {
229 len += 1;
230 }
231 if self.parallelism.is_some() {
232 len += 1;
233 }
234 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
235 if self.table_id != 0 {
236 struct_ser.serialize_field("tableId", &self.table_id)?;
237 }
238 if let Some(v) = self.parallelism.as_ref() {
239 struct_ser.serialize_field("parallelism", v)?;
240 }
241 struct_ser.end()
242 }
243}
244impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
245 #[allow(deprecated)]
246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
247 where
248 D: serde::Deserializer<'de>,
249 {
250 const FIELDS: &[&str] = &[
251 "table_id",
252 "tableId",
253 "parallelism",
254 ];
255
256 #[allow(clippy::enum_variant_names)]
257 enum GeneratedField {
258 TableId,
259 Parallelism,
260 }
261 impl<'de> serde::Deserialize<'de> for GeneratedField {
262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
263 where
264 D: serde::Deserializer<'de>,
265 {
266 struct GeneratedVisitor;
267
268 impl serde::de::Visitor<'_> for GeneratedVisitor {
269 type Value = GeneratedField;
270
271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 write!(formatter, "expected one of: {:?}", &FIELDS)
273 }
274
275 #[allow(unused_variables)]
276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
277 where
278 E: serde::de::Error,
279 {
280 match value {
281 "tableId" | "table_id" => Ok(GeneratedField::TableId),
282 "parallelism" => Ok(GeneratedField::Parallelism),
283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
284 }
285 }
286 }
287 deserializer.deserialize_identifier(GeneratedVisitor)
288 }
289 }
290 struct GeneratedVisitor;
291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
292 type Value = AlterCdcTableBackfillParallelismRequest;
293
294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
295 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
296 }
297
298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
299 where
300 V: serde::de::MapAccess<'de>,
301 {
302 let mut table_id__ = None;
303 let mut parallelism__ = None;
304 while let Some(k) = map_.next_key()? {
305 match k {
306 GeneratedField::TableId => {
307 if table_id__.is_some() {
308 return Err(serde::de::Error::duplicate_field("tableId"));
309 }
310 table_id__ =
311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
312 ;
313 }
314 GeneratedField::Parallelism => {
315 if parallelism__.is_some() {
316 return Err(serde::de::Error::duplicate_field("parallelism"));
317 }
318 parallelism__ = map_.next_value()?;
319 }
320 }
321 }
322 Ok(AlterCdcTableBackfillParallelismRequest {
323 table_id: table_id__.unwrap_or_default(),
324 parallelism: parallelism__,
325 })
326 }
327 }
328 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
329 }
330}
331impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
332 #[allow(deprecated)]
333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334 where
335 S: serde::Serializer,
336 {
337 use serde::ser::SerializeStruct;
338 let len = 0;
339 let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
340 struct_ser.end()
341 }
342}
343impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
344 #[allow(deprecated)]
345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
346 where
347 D: serde::Deserializer<'de>,
348 {
349 const FIELDS: &[&str] = &[
350 ];
351
352 #[allow(clippy::enum_variant_names)]
353 enum GeneratedField {
354 }
355 impl<'de> serde::Deserialize<'de> for GeneratedField {
356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
357 where
358 D: serde::Deserializer<'de>,
359 {
360 struct GeneratedVisitor;
361
362 impl serde::de::Visitor<'_> for GeneratedVisitor {
363 type Value = GeneratedField;
364
365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
366 write!(formatter, "expected one of: {:?}", &FIELDS)
367 }
368
369 #[allow(unused_variables)]
370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
371 where
372 E: serde::de::Error,
373 {
374 Err(serde::de::Error::unknown_field(value, FIELDS))
375 }
376 }
377 deserializer.deserialize_identifier(GeneratedVisitor)
378 }
379 }
380 struct GeneratedVisitor;
381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
382 type Value = AlterCdcTableBackfillParallelismResponse;
383
384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
385 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
386 }
387
388 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
389 where
390 V: serde::de::MapAccess<'de>,
391 {
392 while map_.next_key::<GeneratedField>()?.is_some() {
393 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
394 }
395 Ok(AlterCdcTableBackfillParallelismResponse {
396 })
397 }
398 }
399 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
400 }
401}
402impl serde::Serialize for AlterDatabaseParamRequest {
403 #[allow(deprecated)]
404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
405 where
406 S: serde::Serializer,
407 {
408 use serde::ser::SerializeStruct;
409 let mut len = 0;
410 if self.database_id != 0 {
411 len += 1;
412 }
413 if self.param.is_some() {
414 len += 1;
415 }
416 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
417 if self.database_id != 0 {
418 struct_ser.serialize_field("databaseId", &self.database_id)?;
419 }
420 if let Some(v) = self.param.as_ref() {
421 match v {
422 alter_database_param_request::Param::BarrierIntervalMs(v) => {
423 struct_ser.serialize_field("barrierIntervalMs", v)?;
424 }
425 alter_database_param_request::Param::CheckpointFrequency(v) => {
426 struct_ser.serialize_field("checkpointFrequency", v)?;
427 }
428 }
429 }
430 struct_ser.end()
431 }
432}
433impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
434 #[allow(deprecated)]
435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
436 where
437 D: serde::Deserializer<'de>,
438 {
439 const FIELDS: &[&str] = &[
440 "database_id",
441 "databaseId",
442 "barrier_interval_ms",
443 "barrierIntervalMs",
444 "checkpoint_frequency",
445 "checkpointFrequency",
446 ];
447
448 #[allow(clippy::enum_variant_names)]
449 enum GeneratedField {
450 DatabaseId,
451 BarrierIntervalMs,
452 CheckpointFrequency,
453 }
454 impl<'de> serde::Deserialize<'de> for GeneratedField {
455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
456 where
457 D: serde::Deserializer<'de>,
458 {
459 struct GeneratedVisitor;
460
461 impl serde::de::Visitor<'_> for GeneratedVisitor {
462 type Value = GeneratedField;
463
464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
465 write!(formatter, "expected one of: {:?}", &FIELDS)
466 }
467
468 #[allow(unused_variables)]
469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
470 where
471 E: serde::de::Error,
472 {
473 match value {
474 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
475 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
476 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
478 }
479 }
480 }
481 deserializer.deserialize_identifier(GeneratedVisitor)
482 }
483 }
484 struct GeneratedVisitor;
485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
486 type Value = AlterDatabaseParamRequest;
487
488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
489 formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
490 }
491
492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
493 where
494 V: serde::de::MapAccess<'de>,
495 {
496 let mut database_id__ = None;
497 let mut param__ = None;
498 while let Some(k) = map_.next_key()? {
499 match k {
500 GeneratedField::DatabaseId => {
501 if database_id__.is_some() {
502 return Err(serde::de::Error::duplicate_field("databaseId"));
503 }
504 database_id__ =
505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
506 ;
507 }
508 GeneratedField::BarrierIntervalMs => {
509 if param__.is_some() {
510 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
511 }
512 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
513;
514 }
515 GeneratedField::CheckpointFrequency => {
516 if param__.is_some() {
517 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
518 }
519 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
520;
521 }
522 }
523 }
524 Ok(AlterDatabaseParamRequest {
525 database_id: database_id__.unwrap_or_default(),
526 param: param__,
527 })
528 }
529 }
530 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
531 }
532}
533impl serde::Serialize for AlterDatabaseParamResponse {
534 #[allow(deprecated)]
535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
536 where
537 S: serde::Serializer,
538 {
539 use serde::ser::SerializeStruct;
540 let mut len = 0;
541 if self.status.is_some() {
542 len += 1;
543 }
544 if self.version.is_some() {
545 len += 1;
546 }
547 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
548 if let Some(v) = self.status.as_ref() {
549 struct_ser.serialize_field("status", v)?;
550 }
551 if let Some(v) = self.version.as_ref() {
552 struct_ser.serialize_field("version", v)?;
553 }
554 struct_ser.end()
555 }
556}
557impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
558 #[allow(deprecated)]
559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
560 where
561 D: serde::Deserializer<'de>,
562 {
563 const FIELDS: &[&str] = &[
564 "status",
565 "version",
566 ];
567
568 #[allow(clippy::enum_variant_names)]
569 enum GeneratedField {
570 Status,
571 Version,
572 }
573 impl<'de> serde::Deserialize<'de> for GeneratedField {
574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
575 where
576 D: serde::Deserializer<'de>,
577 {
578 struct GeneratedVisitor;
579
580 impl serde::de::Visitor<'_> for GeneratedVisitor {
581 type Value = GeneratedField;
582
583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
584 write!(formatter, "expected one of: {:?}", &FIELDS)
585 }
586
587 #[allow(unused_variables)]
588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
589 where
590 E: serde::de::Error,
591 {
592 match value {
593 "status" => Ok(GeneratedField::Status),
594 "version" => Ok(GeneratedField::Version),
595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
596 }
597 }
598 }
599 deserializer.deserialize_identifier(GeneratedVisitor)
600 }
601 }
602 struct GeneratedVisitor;
603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
604 type Value = AlterDatabaseParamResponse;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
608 }
609
610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
611 where
612 V: serde::de::MapAccess<'de>,
613 {
614 let mut status__ = None;
615 let mut version__ = None;
616 while let Some(k) = map_.next_key()? {
617 match k {
618 GeneratedField::Status => {
619 if status__.is_some() {
620 return Err(serde::de::Error::duplicate_field("status"));
621 }
622 status__ = map_.next_value()?;
623 }
624 GeneratedField::Version => {
625 if version__.is_some() {
626 return Err(serde::de::Error::duplicate_field("version"));
627 }
628 version__ = map_.next_value()?;
629 }
630 }
631 }
632 Ok(AlterDatabaseParamResponse {
633 status: status__,
634 version: version__,
635 })
636 }
637 }
638 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
639 }
640}
641impl serde::Serialize for AlterFragmentParallelismRequest {
642 #[allow(deprecated)]
643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
644 where
645 S: serde::Serializer,
646 {
647 use serde::ser::SerializeStruct;
648 let mut len = 0;
649 if !self.fragment_ids.is_empty() {
650 len += 1;
651 }
652 if self.parallelism.is_some() {
653 len += 1;
654 }
655 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismRequest", len)?;
656 if !self.fragment_ids.is_empty() {
657 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
658 }
659 if let Some(v) = self.parallelism.as_ref() {
660 struct_ser.serialize_field("parallelism", v)?;
661 }
662 struct_ser.end()
663 }
664}
665impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismRequest {
666 #[allow(deprecated)]
667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
668 where
669 D: serde::Deserializer<'de>,
670 {
671 const FIELDS: &[&str] = &[
672 "fragment_ids",
673 "fragmentIds",
674 "parallelism",
675 ];
676
677 #[allow(clippy::enum_variant_names)]
678 enum GeneratedField {
679 FragmentIds,
680 Parallelism,
681 }
682 impl<'de> serde::Deserialize<'de> for GeneratedField {
683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
684 where
685 D: serde::Deserializer<'de>,
686 {
687 struct GeneratedVisitor;
688
689 impl serde::de::Visitor<'_> for GeneratedVisitor {
690 type Value = GeneratedField;
691
692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
693 write!(formatter, "expected one of: {:?}", &FIELDS)
694 }
695
696 #[allow(unused_variables)]
697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
698 where
699 E: serde::de::Error,
700 {
701 match value {
702 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
703 "parallelism" => Ok(GeneratedField::Parallelism),
704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
705 }
706 }
707 }
708 deserializer.deserialize_identifier(GeneratedVisitor)
709 }
710 }
711 struct GeneratedVisitor;
712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
713 type Value = AlterFragmentParallelismRequest;
714
715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
716 formatter.write_str("struct ddl_service.AlterFragmentParallelismRequest")
717 }
718
719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismRequest, V::Error>
720 where
721 V: serde::de::MapAccess<'de>,
722 {
723 let mut fragment_ids__ = None;
724 let mut parallelism__ = None;
725 while let Some(k) = map_.next_key()? {
726 match k {
727 GeneratedField::FragmentIds => {
728 if fragment_ids__.is_some() {
729 return Err(serde::de::Error::duplicate_field("fragmentIds"));
730 }
731 fragment_ids__ =
732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
733 .into_iter().map(|x| x.0).collect())
734 ;
735 }
736 GeneratedField::Parallelism => {
737 if parallelism__.is_some() {
738 return Err(serde::de::Error::duplicate_field("parallelism"));
739 }
740 parallelism__ = map_.next_value()?;
741 }
742 }
743 }
744 Ok(AlterFragmentParallelismRequest {
745 fragment_ids: fragment_ids__.unwrap_or_default(),
746 parallelism: parallelism__,
747 })
748 }
749 }
750 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismRequest", FIELDS, GeneratedVisitor)
751 }
752}
753impl serde::Serialize for AlterFragmentParallelismResponse {
754 #[allow(deprecated)]
755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
756 where
757 S: serde::Serializer,
758 {
759 use serde::ser::SerializeStruct;
760 let len = 0;
761 let struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismResponse", len)?;
762 struct_ser.end()
763 }
764}
765impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismResponse {
766 #[allow(deprecated)]
767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
768 where
769 D: serde::Deserializer<'de>,
770 {
771 const FIELDS: &[&str] = &[
772 ];
773
774 #[allow(clippy::enum_variant_names)]
775 enum GeneratedField {
776 }
777 impl<'de> serde::Deserialize<'de> for GeneratedField {
778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
779 where
780 D: serde::Deserializer<'de>,
781 {
782 struct GeneratedVisitor;
783
784 impl serde::de::Visitor<'_> for GeneratedVisitor {
785 type Value = GeneratedField;
786
787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
788 write!(formatter, "expected one of: {:?}", &FIELDS)
789 }
790
791 #[allow(unused_variables)]
792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
793 where
794 E: serde::de::Error,
795 {
796 Err(serde::de::Error::unknown_field(value, FIELDS))
797 }
798 }
799 deserializer.deserialize_identifier(GeneratedVisitor)
800 }
801 }
802 struct GeneratedVisitor;
803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
804 type Value = AlterFragmentParallelismResponse;
805
806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
807 formatter.write_str("struct ddl_service.AlterFragmentParallelismResponse")
808 }
809
810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismResponse, V::Error>
811 where
812 V: serde::de::MapAccess<'de>,
813 {
814 while map_.next_key::<GeneratedField>()?.is_some() {
815 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
816 }
817 Ok(AlterFragmentParallelismResponse {
818 })
819 }
820 }
821 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismResponse", FIELDS, GeneratedVisitor)
822 }
823}
824impl serde::Serialize for AlterNameRequest {
825 #[allow(deprecated)]
826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
827 where
828 S: serde::Serializer,
829 {
830 use serde::ser::SerializeStruct;
831 let mut len = 0;
832 if !self.new_name.is_empty() {
833 len += 1;
834 }
835 if self.object.is_some() {
836 len += 1;
837 }
838 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
839 if !self.new_name.is_empty() {
840 struct_ser.serialize_field("newName", &self.new_name)?;
841 }
842 if let Some(v) = self.object.as_ref() {
843 match v {
844 alter_name_request::Object::TableId(v) => {
845 struct_ser.serialize_field("tableId", v)?;
846 }
847 alter_name_request::Object::ViewId(v) => {
848 struct_ser.serialize_field("viewId", v)?;
849 }
850 alter_name_request::Object::IndexId(v) => {
851 struct_ser.serialize_field("indexId", v)?;
852 }
853 alter_name_request::Object::SinkId(v) => {
854 struct_ser.serialize_field("sinkId", v)?;
855 }
856 alter_name_request::Object::SourceId(v) => {
857 struct_ser.serialize_field("sourceId", v)?;
858 }
859 alter_name_request::Object::SchemaId(v) => {
860 struct_ser.serialize_field("schemaId", v)?;
861 }
862 alter_name_request::Object::DatabaseId(v) => {
863 struct_ser.serialize_field("databaseId", v)?;
864 }
865 alter_name_request::Object::SubscriptionId(v) => {
866 struct_ser.serialize_field("subscriptionId", v)?;
867 }
868 }
869 }
870 struct_ser.end()
871 }
872}
873impl<'de> serde::Deserialize<'de> for AlterNameRequest {
874 #[allow(deprecated)]
875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
876 where
877 D: serde::Deserializer<'de>,
878 {
879 const FIELDS: &[&str] = &[
880 "new_name",
881 "newName",
882 "table_id",
883 "tableId",
884 "view_id",
885 "viewId",
886 "index_id",
887 "indexId",
888 "sink_id",
889 "sinkId",
890 "source_id",
891 "sourceId",
892 "schema_id",
893 "schemaId",
894 "database_id",
895 "databaseId",
896 "subscription_id",
897 "subscriptionId",
898 ];
899
900 #[allow(clippy::enum_variant_names)]
901 enum GeneratedField {
902 NewName,
903 TableId,
904 ViewId,
905 IndexId,
906 SinkId,
907 SourceId,
908 SchemaId,
909 DatabaseId,
910 SubscriptionId,
911 }
912 impl<'de> serde::Deserialize<'de> for GeneratedField {
913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
914 where
915 D: serde::Deserializer<'de>,
916 {
917 struct GeneratedVisitor;
918
919 impl serde::de::Visitor<'_> for GeneratedVisitor {
920 type Value = GeneratedField;
921
922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
923 write!(formatter, "expected one of: {:?}", &FIELDS)
924 }
925
926 #[allow(unused_variables)]
927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
928 where
929 E: serde::de::Error,
930 {
931 match value {
932 "newName" | "new_name" => Ok(GeneratedField::NewName),
933 "tableId" | "table_id" => Ok(GeneratedField::TableId),
934 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
935 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
936 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
937 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
938 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
939 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
940 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
942 }
943 }
944 }
945 deserializer.deserialize_identifier(GeneratedVisitor)
946 }
947 }
948 struct GeneratedVisitor;
949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
950 type Value = AlterNameRequest;
951
952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
953 formatter.write_str("struct ddl_service.AlterNameRequest")
954 }
955
956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
957 where
958 V: serde::de::MapAccess<'de>,
959 {
960 let mut new_name__ = None;
961 let mut object__ = None;
962 while let Some(k) = map_.next_key()? {
963 match k {
964 GeneratedField::NewName => {
965 if new_name__.is_some() {
966 return Err(serde::de::Error::duplicate_field("newName"));
967 }
968 new_name__ = Some(map_.next_value()?);
969 }
970 GeneratedField::TableId => {
971 if object__.is_some() {
972 return Err(serde::de::Error::duplicate_field("tableId"));
973 }
974 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
975 }
976 GeneratedField::ViewId => {
977 if object__.is_some() {
978 return Err(serde::de::Error::duplicate_field("viewId"));
979 }
980 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
981 }
982 GeneratedField::IndexId => {
983 if object__.is_some() {
984 return Err(serde::de::Error::duplicate_field("indexId"));
985 }
986 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
987 }
988 GeneratedField::SinkId => {
989 if object__.is_some() {
990 return Err(serde::de::Error::duplicate_field("sinkId"));
991 }
992 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
993 }
994 GeneratedField::SourceId => {
995 if object__.is_some() {
996 return Err(serde::de::Error::duplicate_field("sourceId"));
997 }
998 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
999 }
1000 GeneratedField::SchemaId => {
1001 if object__.is_some() {
1002 return Err(serde::de::Error::duplicate_field("schemaId"));
1003 }
1004 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
1005 }
1006 GeneratedField::DatabaseId => {
1007 if object__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("databaseId"));
1009 }
1010 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
1011 }
1012 GeneratedField::SubscriptionId => {
1013 if object__.is_some() {
1014 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1015 }
1016 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
1017 }
1018 }
1019 }
1020 Ok(AlterNameRequest {
1021 new_name: new_name__.unwrap_or_default(),
1022 object: object__,
1023 })
1024 }
1025 }
1026 deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
1027 }
1028}
1029impl serde::Serialize for AlterNameResponse {
1030 #[allow(deprecated)]
1031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1032 where
1033 S: serde::Serializer,
1034 {
1035 use serde::ser::SerializeStruct;
1036 let mut len = 0;
1037 if self.status.is_some() {
1038 len += 1;
1039 }
1040 if self.version.is_some() {
1041 len += 1;
1042 }
1043 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
1044 if let Some(v) = self.status.as_ref() {
1045 struct_ser.serialize_field("status", v)?;
1046 }
1047 if let Some(v) = self.version.as_ref() {
1048 struct_ser.serialize_field("version", v)?;
1049 }
1050 struct_ser.end()
1051 }
1052}
1053impl<'de> serde::Deserialize<'de> for AlterNameResponse {
1054 #[allow(deprecated)]
1055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1056 where
1057 D: serde::Deserializer<'de>,
1058 {
1059 const FIELDS: &[&str] = &[
1060 "status",
1061 "version",
1062 ];
1063
1064 #[allow(clippy::enum_variant_names)]
1065 enum GeneratedField {
1066 Status,
1067 Version,
1068 }
1069 impl<'de> serde::Deserialize<'de> for GeneratedField {
1070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1071 where
1072 D: serde::Deserializer<'de>,
1073 {
1074 struct GeneratedVisitor;
1075
1076 impl serde::de::Visitor<'_> for GeneratedVisitor {
1077 type Value = GeneratedField;
1078
1079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1080 write!(formatter, "expected one of: {:?}", &FIELDS)
1081 }
1082
1083 #[allow(unused_variables)]
1084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1085 where
1086 E: serde::de::Error,
1087 {
1088 match value {
1089 "status" => Ok(GeneratedField::Status),
1090 "version" => Ok(GeneratedField::Version),
1091 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1092 }
1093 }
1094 }
1095 deserializer.deserialize_identifier(GeneratedVisitor)
1096 }
1097 }
1098 struct GeneratedVisitor;
1099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1100 type Value = AlterNameResponse;
1101
1102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1103 formatter.write_str("struct ddl_service.AlterNameResponse")
1104 }
1105
1106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
1107 where
1108 V: serde::de::MapAccess<'de>,
1109 {
1110 let mut status__ = None;
1111 let mut version__ = None;
1112 while let Some(k) = map_.next_key()? {
1113 match k {
1114 GeneratedField::Status => {
1115 if status__.is_some() {
1116 return Err(serde::de::Error::duplicate_field("status"));
1117 }
1118 status__ = map_.next_value()?;
1119 }
1120 GeneratedField::Version => {
1121 if version__.is_some() {
1122 return Err(serde::de::Error::duplicate_field("version"));
1123 }
1124 version__ = map_.next_value()?;
1125 }
1126 }
1127 }
1128 Ok(AlterNameResponse {
1129 status: status__,
1130 version: version__,
1131 })
1132 }
1133 }
1134 deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
1135 }
1136}
1137impl serde::Serialize for AlterOwnerRequest {
1138 #[allow(deprecated)]
1139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1140 where
1141 S: serde::Serializer,
1142 {
1143 use serde::ser::SerializeStruct;
1144 let mut len = 0;
1145 if self.owner_id != 0 {
1146 len += 1;
1147 }
1148 if self.object.is_some() {
1149 len += 1;
1150 }
1151 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
1152 if self.owner_id != 0 {
1153 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1154 }
1155 if let Some(v) = self.object.as_ref() {
1156 match v {
1157 alter_owner_request::Object::TableId(v) => {
1158 struct_ser.serialize_field("tableId", v)?;
1159 }
1160 alter_owner_request::Object::ViewId(v) => {
1161 struct_ser.serialize_field("viewId", v)?;
1162 }
1163 alter_owner_request::Object::SourceId(v) => {
1164 struct_ser.serialize_field("sourceId", v)?;
1165 }
1166 alter_owner_request::Object::SinkId(v) => {
1167 struct_ser.serialize_field("sinkId", v)?;
1168 }
1169 alter_owner_request::Object::SchemaId(v) => {
1170 struct_ser.serialize_field("schemaId", v)?;
1171 }
1172 alter_owner_request::Object::DatabaseId(v) => {
1173 struct_ser.serialize_field("databaseId", v)?;
1174 }
1175 alter_owner_request::Object::SubscriptionId(v) => {
1176 struct_ser.serialize_field("subscriptionId", v)?;
1177 }
1178 alter_owner_request::Object::ConnectionId(v) => {
1179 struct_ser.serialize_field("connectionId", v)?;
1180 }
1181 alter_owner_request::Object::SecretId(v) => {
1182 struct_ser.serialize_field("secretId", v)?;
1183 }
1184 alter_owner_request::Object::FunctionId(v) => {
1185 struct_ser.serialize_field("functionId", v)?;
1186 }
1187 }
1188 }
1189 struct_ser.end()
1190 }
1191}
1192impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
1193 #[allow(deprecated)]
1194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1195 where
1196 D: serde::Deserializer<'de>,
1197 {
1198 const FIELDS: &[&str] = &[
1199 "owner_id",
1200 "ownerId",
1201 "table_id",
1202 "tableId",
1203 "view_id",
1204 "viewId",
1205 "source_id",
1206 "sourceId",
1207 "sink_id",
1208 "sinkId",
1209 "schema_id",
1210 "schemaId",
1211 "database_id",
1212 "databaseId",
1213 "subscription_id",
1214 "subscriptionId",
1215 "connection_id",
1216 "connectionId",
1217 "secret_id",
1218 "secretId",
1219 "function_id",
1220 "functionId",
1221 ];
1222
1223 #[allow(clippy::enum_variant_names)]
1224 enum GeneratedField {
1225 OwnerId,
1226 TableId,
1227 ViewId,
1228 SourceId,
1229 SinkId,
1230 SchemaId,
1231 DatabaseId,
1232 SubscriptionId,
1233 ConnectionId,
1234 SecretId,
1235 FunctionId,
1236 }
1237 impl<'de> serde::Deserialize<'de> for GeneratedField {
1238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1239 where
1240 D: serde::Deserializer<'de>,
1241 {
1242 struct GeneratedVisitor;
1243
1244 impl serde::de::Visitor<'_> for GeneratedVisitor {
1245 type Value = GeneratedField;
1246
1247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1248 write!(formatter, "expected one of: {:?}", &FIELDS)
1249 }
1250
1251 #[allow(unused_variables)]
1252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1253 where
1254 E: serde::de::Error,
1255 {
1256 match value {
1257 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1258 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1259 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1260 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1261 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1262 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1263 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1264 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1265 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1266 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1267 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1269 }
1270 }
1271 }
1272 deserializer.deserialize_identifier(GeneratedVisitor)
1273 }
1274 }
1275 struct GeneratedVisitor;
1276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1277 type Value = AlterOwnerRequest;
1278
1279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1280 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1281 }
1282
1283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1284 where
1285 V: serde::de::MapAccess<'de>,
1286 {
1287 let mut owner_id__ = None;
1288 let mut object__ = None;
1289 while let Some(k) = map_.next_key()? {
1290 match k {
1291 GeneratedField::OwnerId => {
1292 if owner_id__.is_some() {
1293 return Err(serde::de::Error::duplicate_field("ownerId"));
1294 }
1295 owner_id__ =
1296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1297 ;
1298 }
1299 GeneratedField::TableId => {
1300 if object__.is_some() {
1301 return Err(serde::de::Error::duplicate_field("tableId"));
1302 }
1303 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1304 }
1305 GeneratedField::ViewId => {
1306 if object__.is_some() {
1307 return Err(serde::de::Error::duplicate_field("viewId"));
1308 }
1309 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1310 }
1311 GeneratedField::SourceId => {
1312 if object__.is_some() {
1313 return Err(serde::de::Error::duplicate_field("sourceId"));
1314 }
1315 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1316 }
1317 GeneratedField::SinkId => {
1318 if object__.is_some() {
1319 return Err(serde::de::Error::duplicate_field("sinkId"));
1320 }
1321 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1322 }
1323 GeneratedField::SchemaId => {
1324 if object__.is_some() {
1325 return Err(serde::de::Error::duplicate_field("schemaId"));
1326 }
1327 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1328 }
1329 GeneratedField::DatabaseId => {
1330 if object__.is_some() {
1331 return Err(serde::de::Error::duplicate_field("databaseId"));
1332 }
1333 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1334 }
1335 GeneratedField::SubscriptionId => {
1336 if object__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1338 }
1339 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1340 }
1341 GeneratedField::ConnectionId => {
1342 if object__.is_some() {
1343 return Err(serde::de::Error::duplicate_field("connectionId"));
1344 }
1345 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1346 }
1347 GeneratedField::SecretId => {
1348 if object__.is_some() {
1349 return Err(serde::de::Error::duplicate_field("secretId"));
1350 }
1351 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SecretId(x.0));
1352 }
1353 GeneratedField::FunctionId => {
1354 if object__.is_some() {
1355 return Err(serde::de::Error::duplicate_field("functionId"));
1356 }
1357 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::FunctionId(x.0));
1358 }
1359 }
1360 }
1361 Ok(AlterOwnerRequest {
1362 owner_id: owner_id__.unwrap_or_default(),
1363 object: object__,
1364 })
1365 }
1366 }
1367 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1368 }
1369}
1370impl serde::Serialize for AlterOwnerResponse {
1371 #[allow(deprecated)]
1372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1373 where
1374 S: serde::Serializer,
1375 {
1376 use serde::ser::SerializeStruct;
1377 let mut len = 0;
1378 if self.status.is_some() {
1379 len += 1;
1380 }
1381 if self.version.is_some() {
1382 len += 1;
1383 }
1384 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1385 if let Some(v) = self.status.as_ref() {
1386 struct_ser.serialize_field("status", v)?;
1387 }
1388 if let Some(v) = self.version.as_ref() {
1389 struct_ser.serialize_field("version", v)?;
1390 }
1391 struct_ser.end()
1392 }
1393}
1394impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1395 #[allow(deprecated)]
1396 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1397 where
1398 D: serde::Deserializer<'de>,
1399 {
1400 const FIELDS: &[&str] = &[
1401 "status",
1402 "version",
1403 ];
1404
1405 #[allow(clippy::enum_variant_names)]
1406 enum GeneratedField {
1407 Status,
1408 Version,
1409 }
1410 impl<'de> serde::Deserialize<'de> for GeneratedField {
1411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1412 where
1413 D: serde::Deserializer<'de>,
1414 {
1415 struct GeneratedVisitor;
1416
1417 impl serde::de::Visitor<'_> for GeneratedVisitor {
1418 type Value = GeneratedField;
1419
1420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1421 write!(formatter, "expected one of: {:?}", &FIELDS)
1422 }
1423
1424 #[allow(unused_variables)]
1425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1426 where
1427 E: serde::de::Error,
1428 {
1429 match value {
1430 "status" => Ok(GeneratedField::Status),
1431 "version" => Ok(GeneratedField::Version),
1432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1433 }
1434 }
1435 }
1436 deserializer.deserialize_identifier(GeneratedVisitor)
1437 }
1438 }
1439 struct GeneratedVisitor;
1440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1441 type Value = AlterOwnerResponse;
1442
1443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1444 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1445 }
1446
1447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1448 where
1449 V: serde::de::MapAccess<'de>,
1450 {
1451 let mut status__ = None;
1452 let mut version__ = None;
1453 while let Some(k) = map_.next_key()? {
1454 match k {
1455 GeneratedField::Status => {
1456 if status__.is_some() {
1457 return Err(serde::de::Error::duplicate_field("status"));
1458 }
1459 status__ = map_.next_value()?;
1460 }
1461 GeneratedField::Version => {
1462 if version__.is_some() {
1463 return Err(serde::de::Error::duplicate_field("version"));
1464 }
1465 version__ = map_.next_value()?;
1466 }
1467 }
1468 }
1469 Ok(AlterOwnerResponse {
1470 status: status__,
1471 version: version__,
1472 })
1473 }
1474 }
1475 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1476 }
1477}
1478impl serde::Serialize for AlterParallelismRequest {
1479 #[allow(deprecated)]
1480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1481 where
1482 S: serde::Serializer,
1483 {
1484 use serde::ser::SerializeStruct;
1485 let mut len = 0;
1486 if self.table_id != 0 {
1487 len += 1;
1488 }
1489 if self.parallelism.is_some() {
1490 len += 1;
1491 }
1492 if self.deferred {
1493 len += 1;
1494 }
1495 if self.adaptive_parallelism_strategy.is_some() {
1496 len += 1;
1497 }
1498 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1499 if self.table_id != 0 {
1500 struct_ser.serialize_field("tableId", &self.table_id)?;
1501 }
1502 if let Some(v) = self.parallelism.as_ref() {
1503 struct_ser.serialize_field("parallelism", v)?;
1504 }
1505 if self.deferred {
1506 struct_ser.serialize_field("deferred", &self.deferred)?;
1507 }
1508 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
1509 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
1510 }
1511 struct_ser.end()
1512 }
1513}
1514impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1515 #[allow(deprecated)]
1516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1517 where
1518 D: serde::Deserializer<'de>,
1519 {
1520 const FIELDS: &[&str] = &[
1521 "table_id",
1522 "tableId",
1523 "parallelism",
1524 "deferred",
1525 "adaptive_parallelism_strategy",
1526 "adaptiveParallelismStrategy",
1527 ];
1528
1529 #[allow(clippy::enum_variant_names)]
1530 enum GeneratedField {
1531 TableId,
1532 Parallelism,
1533 Deferred,
1534 AdaptiveParallelismStrategy,
1535 }
1536 impl<'de> serde::Deserialize<'de> for GeneratedField {
1537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1538 where
1539 D: serde::Deserializer<'de>,
1540 {
1541 struct GeneratedVisitor;
1542
1543 impl serde::de::Visitor<'_> for GeneratedVisitor {
1544 type Value = GeneratedField;
1545
1546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1547 write!(formatter, "expected one of: {:?}", &FIELDS)
1548 }
1549
1550 #[allow(unused_variables)]
1551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1552 where
1553 E: serde::de::Error,
1554 {
1555 match value {
1556 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1557 "parallelism" => Ok(GeneratedField::Parallelism),
1558 "deferred" => Ok(GeneratedField::Deferred),
1559 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
1560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1561 }
1562 }
1563 }
1564 deserializer.deserialize_identifier(GeneratedVisitor)
1565 }
1566 }
1567 struct GeneratedVisitor;
1568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1569 type Value = AlterParallelismRequest;
1570
1571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1572 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1573 }
1574
1575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1576 where
1577 V: serde::de::MapAccess<'de>,
1578 {
1579 let mut table_id__ = None;
1580 let mut parallelism__ = None;
1581 let mut deferred__ = None;
1582 let mut adaptive_parallelism_strategy__ = None;
1583 while let Some(k) = map_.next_key()? {
1584 match k {
1585 GeneratedField::TableId => {
1586 if table_id__.is_some() {
1587 return Err(serde::de::Error::duplicate_field("tableId"));
1588 }
1589 table_id__ =
1590 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1591 ;
1592 }
1593 GeneratedField::Parallelism => {
1594 if parallelism__.is_some() {
1595 return Err(serde::de::Error::duplicate_field("parallelism"));
1596 }
1597 parallelism__ = map_.next_value()?;
1598 }
1599 GeneratedField::Deferred => {
1600 if deferred__.is_some() {
1601 return Err(serde::de::Error::duplicate_field("deferred"));
1602 }
1603 deferred__ = Some(map_.next_value()?);
1604 }
1605 GeneratedField::AdaptiveParallelismStrategy => {
1606 if adaptive_parallelism_strategy__.is_some() {
1607 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
1608 }
1609 adaptive_parallelism_strategy__ = map_.next_value()?;
1610 }
1611 }
1612 }
1613 Ok(AlterParallelismRequest {
1614 table_id: table_id__.unwrap_or_default(),
1615 parallelism: parallelism__,
1616 deferred: deferred__.unwrap_or_default(),
1617 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
1618 })
1619 }
1620 }
1621 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1622 }
1623}
1624impl serde::Serialize for AlterParallelismResponse {
1625 #[allow(deprecated)]
1626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1627 where
1628 S: serde::Serializer,
1629 {
1630 use serde::ser::SerializeStruct;
1631 let len = 0;
1632 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1633 struct_ser.end()
1634 }
1635}
1636impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1637 #[allow(deprecated)]
1638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1639 where
1640 D: serde::Deserializer<'de>,
1641 {
1642 const FIELDS: &[&str] = &[
1643 ];
1644
1645 #[allow(clippy::enum_variant_names)]
1646 enum GeneratedField {
1647 }
1648 impl<'de> serde::Deserialize<'de> for GeneratedField {
1649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1650 where
1651 D: serde::Deserializer<'de>,
1652 {
1653 struct GeneratedVisitor;
1654
1655 impl serde::de::Visitor<'_> for GeneratedVisitor {
1656 type Value = GeneratedField;
1657
1658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1659 write!(formatter, "expected one of: {:?}", &FIELDS)
1660 }
1661
1662 #[allow(unused_variables)]
1663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1664 where
1665 E: serde::de::Error,
1666 {
1667 Err(serde::de::Error::unknown_field(value, FIELDS))
1668 }
1669 }
1670 deserializer.deserialize_identifier(GeneratedVisitor)
1671 }
1672 }
1673 struct GeneratedVisitor;
1674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1675 type Value = AlterParallelismResponse;
1676
1677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1678 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1679 }
1680
1681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1682 where
1683 V: serde::de::MapAccess<'de>,
1684 {
1685 while map_.next_key::<GeneratedField>()?.is_some() {
1686 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1687 }
1688 Ok(AlterParallelismResponse {
1689 })
1690 }
1691 }
1692 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1693 }
1694}
1695impl serde::Serialize for AlterResourceGroupRequest {
1696 #[allow(deprecated)]
1697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1698 where
1699 S: serde::Serializer,
1700 {
1701 use serde::ser::SerializeStruct;
1702 let mut len = 0;
1703 if self.table_id != 0 {
1704 len += 1;
1705 }
1706 if self.resource_group.is_some() {
1707 len += 1;
1708 }
1709 if self.deferred {
1710 len += 1;
1711 }
1712 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1713 if self.table_id != 0 {
1714 struct_ser.serialize_field("tableId", &self.table_id)?;
1715 }
1716 if let Some(v) = self.resource_group.as_ref() {
1717 struct_ser.serialize_field("resourceGroup", v)?;
1718 }
1719 if self.deferred {
1720 struct_ser.serialize_field("deferred", &self.deferred)?;
1721 }
1722 struct_ser.end()
1723 }
1724}
1725impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1726 #[allow(deprecated)]
1727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1728 where
1729 D: serde::Deserializer<'de>,
1730 {
1731 const FIELDS: &[&str] = &[
1732 "table_id",
1733 "tableId",
1734 "resource_group",
1735 "resourceGroup",
1736 "deferred",
1737 ];
1738
1739 #[allow(clippy::enum_variant_names)]
1740 enum GeneratedField {
1741 TableId,
1742 ResourceGroup,
1743 Deferred,
1744 }
1745 impl<'de> serde::Deserialize<'de> for GeneratedField {
1746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1747 where
1748 D: serde::Deserializer<'de>,
1749 {
1750 struct GeneratedVisitor;
1751
1752 impl serde::de::Visitor<'_> for GeneratedVisitor {
1753 type Value = GeneratedField;
1754
1755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1756 write!(formatter, "expected one of: {:?}", &FIELDS)
1757 }
1758
1759 #[allow(unused_variables)]
1760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1761 where
1762 E: serde::de::Error,
1763 {
1764 match value {
1765 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1766 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1767 "deferred" => Ok(GeneratedField::Deferred),
1768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1769 }
1770 }
1771 }
1772 deserializer.deserialize_identifier(GeneratedVisitor)
1773 }
1774 }
1775 struct GeneratedVisitor;
1776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1777 type Value = AlterResourceGroupRequest;
1778
1779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1780 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1781 }
1782
1783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1784 where
1785 V: serde::de::MapAccess<'de>,
1786 {
1787 let mut table_id__ = None;
1788 let mut resource_group__ = None;
1789 let mut deferred__ = None;
1790 while let Some(k) = map_.next_key()? {
1791 match k {
1792 GeneratedField::TableId => {
1793 if table_id__.is_some() {
1794 return Err(serde::de::Error::duplicate_field("tableId"));
1795 }
1796 table_id__ =
1797 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1798 ;
1799 }
1800 GeneratedField::ResourceGroup => {
1801 if resource_group__.is_some() {
1802 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1803 }
1804 resource_group__ = map_.next_value()?;
1805 }
1806 GeneratedField::Deferred => {
1807 if deferred__.is_some() {
1808 return Err(serde::de::Error::duplicate_field("deferred"));
1809 }
1810 deferred__ = Some(map_.next_value()?);
1811 }
1812 }
1813 }
1814 Ok(AlterResourceGroupRequest {
1815 table_id: table_id__.unwrap_or_default(),
1816 resource_group: resource_group__,
1817 deferred: deferred__.unwrap_or_default(),
1818 })
1819 }
1820 }
1821 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1822 }
1823}
1824impl serde::Serialize for AlterResourceGroupResponse {
1825 #[allow(deprecated)]
1826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1827 where
1828 S: serde::Serializer,
1829 {
1830 use serde::ser::SerializeStruct;
1831 let len = 0;
1832 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1833 struct_ser.end()
1834 }
1835}
1836impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1837 #[allow(deprecated)]
1838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1839 where
1840 D: serde::Deserializer<'de>,
1841 {
1842 const FIELDS: &[&str] = &[
1843 ];
1844
1845 #[allow(clippy::enum_variant_names)]
1846 enum GeneratedField {
1847 }
1848 impl<'de> serde::Deserialize<'de> for GeneratedField {
1849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1850 where
1851 D: serde::Deserializer<'de>,
1852 {
1853 struct GeneratedVisitor;
1854
1855 impl serde::de::Visitor<'_> for GeneratedVisitor {
1856 type Value = GeneratedField;
1857
1858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1859 write!(formatter, "expected one of: {:?}", &FIELDS)
1860 }
1861
1862 #[allow(unused_variables)]
1863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1864 where
1865 E: serde::de::Error,
1866 {
1867 Err(serde::de::Error::unknown_field(value, FIELDS))
1868 }
1869 }
1870 deserializer.deserialize_identifier(GeneratedVisitor)
1871 }
1872 }
1873 struct GeneratedVisitor;
1874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1875 type Value = AlterResourceGroupResponse;
1876
1877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1878 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1879 }
1880
1881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1882 where
1883 V: serde::de::MapAccess<'de>,
1884 {
1885 while map_.next_key::<GeneratedField>()?.is_some() {
1886 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1887 }
1888 Ok(AlterResourceGroupResponse {
1889 })
1890 }
1891 }
1892 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1893 }
1894}
1895impl serde::Serialize for AlterSecretRequest {
1896 #[allow(deprecated)]
1897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1898 where
1899 S: serde::Serializer,
1900 {
1901 use serde::ser::SerializeStruct;
1902 let mut len = 0;
1903 if self.secret_id != 0 {
1904 len += 1;
1905 }
1906 if !self.name.is_empty() {
1907 len += 1;
1908 }
1909 if !self.value.is_empty() {
1910 len += 1;
1911 }
1912 if self.database_id != 0 {
1913 len += 1;
1914 }
1915 if self.schema_id != 0 {
1916 len += 1;
1917 }
1918 if self.owner_id != 0 {
1919 len += 1;
1920 }
1921 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1922 if self.secret_id != 0 {
1923 struct_ser.serialize_field("secretId", &self.secret_id)?;
1924 }
1925 if !self.name.is_empty() {
1926 struct_ser.serialize_field("name", &self.name)?;
1927 }
1928 if !self.value.is_empty() {
1929 #[allow(clippy::needless_borrow)]
1930 #[allow(clippy::needless_borrows_for_generic_args)]
1931 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1932 }
1933 if self.database_id != 0 {
1934 struct_ser.serialize_field("databaseId", &self.database_id)?;
1935 }
1936 if self.schema_id != 0 {
1937 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1938 }
1939 if self.owner_id != 0 {
1940 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1941 }
1942 struct_ser.end()
1943 }
1944}
1945impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1946 #[allow(deprecated)]
1947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1948 where
1949 D: serde::Deserializer<'de>,
1950 {
1951 const FIELDS: &[&str] = &[
1952 "secret_id",
1953 "secretId",
1954 "name",
1955 "value",
1956 "database_id",
1957 "databaseId",
1958 "schema_id",
1959 "schemaId",
1960 "owner_id",
1961 "ownerId",
1962 ];
1963
1964 #[allow(clippy::enum_variant_names)]
1965 enum GeneratedField {
1966 SecretId,
1967 Name,
1968 Value,
1969 DatabaseId,
1970 SchemaId,
1971 OwnerId,
1972 }
1973 impl<'de> serde::Deserialize<'de> for GeneratedField {
1974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1975 where
1976 D: serde::Deserializer<'de>,
1977 {
1978 struct GeneratedVisitor;
1979
1980 impl serde::de::Visitor<'_> for GeneratedVisitor {
1981 type Value = GeneratedField;
1982
1983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1984 write!(formatter, "expected one of: {:?}", &FIELDS)
1985 }
1986
1987 #[allow(unused_variables)]
1988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1989 where
1990 E: serde::de::Error,
1991 {
1992 match value {
1993 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1994 "name" => Ok(GeneratedField::Name),
1995 "value" => Ok(GeneratedField::Value),
1996 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1997 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1998 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1999 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2000 }
2001 }
2002 }
2003 deserializer.deserialize_identifier(GeneratedVisitor)
2004 }
2005 }
2006 struct GeneratedVisitor;
2007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2008 type Value = AlterSecretRequest;
2009
2010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2011 formatter.write_str("struct ddl_service.AlterSecretRequest")
2012 }
2013
2014 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
2015 where
2016 V: serde::de::MapAccess<'de>,
2017 {
2018 let mut secret_id__ = None;
2019 let mut name__ = None;
2020 let mut value__ = None;
2021 let mut database_id__ = None;
2022 let mut schema_id__ = None;
2023 let mut owner_id__ = None;
2024 while let Some(k) = map_.next_key()? {
2025 match k {
2026 GeneratedField::SecretId => {
2027 if secret_id__.is_some() {
2028 return Err(serde::de::Error::duplicate_field("secretId"));
2029 }
2030 secret_id__ =
2031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2032 ;
2033 }
2034 GeneratedField::Name => {
2035 if name__.is_some() {
2036 return Err(serde::de::Error::duplicate_field("name"));
2037 }
2038 name__ = Some(map_.next_value()?);
2039 }
2040 GeneratedField::Value => {
2041 if value__.is_some() {
2042 return Err(serde::de::Error::duplicate_field("value"));
2043 }
2044 value__ =
2045 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2046 ;
2047 }
2048 GeneratedField::DatabaseId => {
2049 if database_id__.is_some() {
2050 return Err(serde::de::Error::duplicate_field("databaseId"));
2051 }
2052 database_id__ =
2053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2054 ;
2055 }
2056 GeneratedField::SchemaId => {
2057 if schema_id__.is_some() {
2058 return Err(serde::de::Error::duplicate_field("schemaId"));
2059 }
2060 schema_id__ =
2061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2062 ;
2063 }
2064 GeneratedField::OwnerId => {
2065 if owner_id__.is_some() {
2066 return Err(serde::de::Error::duplicate_field("ownerId"));
2067 }
2068 owner_id__ =
2069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2070 ;
2071 }
2072 }
2073 }
2074 Ok(AlterSecretRequest {
2075 secret_id: secret_id__.unwrap_or_default(),
2076 name: name__.unwrap_or_default(),
2077 value: value__.unwrap_or_default(),
2078 database_id: database_id__.unwrap_or_default(),
2079 schema_id: schema_id__.unwrap_or_default(),
2080 owner_id: owner_id__.unwrap_or_default(),
2081 })
2082 }
2083 }
2084 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
2085 }
2086}
2087impl serde::Serialize for AlterSecretResponse {
2088 #[allow(deprecated)]
2089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2090 where
2091 S: serde::Serializer,
2092 {
2093 use serde::ser::SerializeStruct;
2094 let mut len = 0;
2095 if self.version.is_some() {
2096 len += 1;
2097 }
2098 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
2099 if let Some(v) = self.version.as_ref() {
2100 struct_ser.serialize_field("version", v)?;
2101 }
2102 struct_ser.end()
2103 }
2104}
2105impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
2106 #[allow(deprecated)]
2107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2108 where
2109 D: serde::Deserializer<'de>,
2110 {
2111 const FIELDS: &[&str] = &[
2112 "version",
2113 ];
2114
2115 #[allow(clippy::enum_variant_names)]
2116 enum GeneratedField {
2117 Version,
2118 }
2119 impl<'de> serde::Deserialize<'de> for GeneratedField {
2120 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2121 where
2122 D: serde::Deserializer<'de>,
2123 {
2124 struct GeneratedVisitor;
2125
2126 impl serde::de::Visitor<'_> for GeneratedVisitor {
2127 type Value = GeneratedField;
2128
2129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2130 write!(formatter, "expected one of: {:?}", &FIELDS)
2131 }
2132
2133 #[allow(unused_variables)]
2134 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2135 where
2136 E: serde::de::Error,
2137 {
2138 match value {
2139 "version" => Ok(GeneratedField::Version),
2140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2141 }
2142 }
2143 }
2144 deserializer.deserialize_identifier(GeneratedVisitor)
2145 }
2146 }
2147 struct GeneratedVisitor;
2148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2149 type Value = AlterSecretResponse;
2150
2151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2152 formatter.write_str("struct ddl_service.AlterSecretResponse")
2153 }
2154
2155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
2156 where
2157 V: serde::de::MapAccess<'de>,
2158 {
2159 let mut version__ = None;
2160 while let Some(k) = map_.next_key()? {
2161 match k {
2162 GeneratedField::Version => {
2163 if version__.is_some() {
2164 return Err(serde::de::Error::duplicate_field("version"));
2165 }
2166 version__ = map_.next_value()?;
2167 }
2168 }
2169 }
2170 Ok(AlterSecretResponse {
2171 version: version__,
2172 })
2173 }
2174 }
2175 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
2176 }
2177}
2178impl serde::Serialize for AlterSetSchemaRequest {
2179 #[allow(deprecated)]
2180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2181 where
2182 S: serde::Serializer,
2183 {
2184 use serde::ser::SerializeStruct;
2185 let mut len = 0;
2186 if self.new_schema_id != 0 {
2187 len += 1;
2188 }
2189 if self.object.is_some() {
2190 len += 1;
2191 }
2192 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
2193 if self.new_schema_id != 0 {
2194 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
2195 }
2196 if let Some(v) = self.object.as_ref() {
2197 match v {
2198 alter_set_schema_request::Object::TableId(v) => {
2199 struct_ser.serialize_field("tableId", v)?;
2200 }
2201 alter_set_schema_request::Object::ViewId(v) => {
2202 struct_ser.serialize_field("viewId", v)?;
2203 }
2204 alter_set_schema_request::Object::SourceId(v) => {
2205 struct_ser.serialize_field("sourceId", v)?;
2206 }
2207 alter_set_schema_request::Object::SinkId(v) => {
2208 struct_ser.serialize_field("sinkId", v)?;
2209 }
2210 alter_set_schema_request::Object::FunctionId(v) => {
2211 struct_ser.serialize_field("functionId", v)?;
2212 }
2213 alter_set_schema_request::Object::ConnectionId(v) => {
2214 struct_ser.serialize_field("connectionId", v)?;
2215 }
2216 alter_set_schema_request::Object::SubscriptionId(v) => {
2217 struct_ser.serialize_field("subscriptionId", v)?;
2218 }
2219 }
2220 }
2221 struct_ser.end()
2222 }
2223}
2224impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
2225 #[allow(deprecated)]
2226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2227 where
2228 D: serde::Deserializer<'de>,
2229 {
2230 const FIELDS: &[&str] = &[
2231 "new_schema_id",
2232 "newSchemaId",
2233 "table_id",
2234 "tableId",
2235 "view_id",
2236 "viewId",
2237 "source_id",
2238 "sourceId",
2239 "sink_id",
2240 "sinkId",
2241 "function_id",
2242 "functionId",
2243 "connection_id",
2244 "connectionId",
2245 "subscription_id",
2246 "subscriptionId",
2247 ];
2248
2249 #[allow(clippy::enum_variant_names)]
2250 enum GeneratedField {
2251 NewSchemaId,
2252 TableId,
2253 ViewId,
2254 SourceId,
2255 SinkId,
2256 FunctionId,
2257 ConnectionId,
2258 SubscriptionId,
2259 }
2260 impl<'de> serde::Deserialize<'de> for GeneratedField {
2261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2262 where
2263 D: serde::Deserializer<'de>,
2264 {
2265 struct GeneratedVisitor;
2266
2267 impl serde::de::Visitor<'_> for GeneratedVisitor {
2268 type Value = GeneratedField;
2269
2270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2271 write!(formatter, "expected one of: {:?}", &FIELDS)
2272 }
2273
2274 #[allow(unused_variables)]
2275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2276 where
2277 E: serde::de::Error,
2278 {
2279 match value {
2280 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2281 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2282 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2283 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2284 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2285 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2286 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2287 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289 }
2290 }
2291 }
2292 deserializer.deserialize_identifier(GeneratedVisitor)
2293 }
2294 }
2295 struct GeneratedVisitor;
2296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297 type Value = AlterSetSchemaRequest;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2301 }
2302
2303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2304 where
2305 V: serde::de::MapAccess<'de>,
2306 {
2307 let mut new_schema_id__ = None;
2308 let mut object__ = None;
2309 while let Some(k) = map_.next_key()? {
2310 match k {
2311 GeneratedField::NewSchemaId => {
2312 if new_schema_id__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2314 }
2315 new_schema_id__ =
2316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2317 ;
2318 }
2319 GeneratedField::TableId => {
2320 if object__.is_some() {
2321 return Err(serde::de::Error::duplicate_field("tableId"));
2322 }
2323 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2324 }
2325 GeneratedField::ViewId => {
2326 if object__.is_some() {
2327 return Err(serde::de::Error::duplicate_field("viewId"));
2328 }
2329 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2330 }
2331 GeneratedField::SourceId => {
2332 if object__.is_some() {
2333 return Err(serde::de::Error::duplicate_field("sourceId"));
2334 }
2335 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2336 }
2337 GeneratedField::SinkId => {
2338 if object__.is_some() {
2339 return Err(serde::de::Error::duplicate_field("sinkId"));
2340 }
2341 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2342 }
2343 GeneratedField::FunctionId => {
2344 if object__.is_some() {
2345 return Err(serde::de::Error::duplicate_field("functionId"));
2346 }
2347 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2348 }
2349 GeneratedField::ConnectionId => {
2350 if object__.is_some() {
2351 return Err(serde::de::Error::duplicate_field("connectionId"));
2352 }
2353 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2354 }
2355 GeneratedField::SubscriptionId => {
2356 if object__.is_some() {
2357 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2358 }
2359 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2360 }
2361 }
2362 }
2363 Ok(AlterSetSchemaRequest {
2364 new_schema_id: new_schema_id__.unwrap_or_default(),
2365 object: object__,
2366 })
2367 }
2368 }
2369 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2370 }
2371}
2372impl serde::Serialize for AlterSetSchemaResponse {
2373 #[allow(deprecated)]
2374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2375 where
2376 S: serde::Serializer,
2377 {
2378 use serde::ser::SerializeStruct;
2379 let mut len = 0;
2380 if self.status.is_some() {
2381 len += 1;
2382 }
2383 if self.version.is_some() {
2384 len += 1;
2385 }
2386 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2387 if let Some(v) = self.status.as_ref() {
2388 struct_ser.serialize_field("status", v)?;
2389 }
2390 if let Some(v) = self.version.as_ref() {
2391 struct_ser.serialize_field("version", v)?;
2392 }
2393 struct_ser.end()
2394 }
2395}
2396impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2397 #[allow(deprecated)]
2398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2399 where
2400 D: serde::Deserializer<'de>,
2401 {
2402 const FIELDS: &[&str] = &[
2403 "status",
2404 "version",
2405 ];
2406
2407 #[allow(clippy::enum_variant_names)]
2408 enum GeneratedField {
2409 Status,
2410 Version,
2411 }
2412 impl<'de> serde::Deserialize<'de> for GeneratedField {
2413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2414 where
2415 D: serde::Deserializer<'de>,
2416 {
2417 struct GeneratedVisitor;
2418
2419 impl serde::de::Visitor<'_> for GeneratedVisitor {
2420 type Value = GeneratedField;
2421
2422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2423 write!(formatter, "expected one of: {:?}", &FIELDS)
2424 }
2425
2426 #[allow(unused_variables)]
2427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2428 where
2429 E: serde::de::Error,
2430 {
2431 match value {
2432 "status" => Ok(GeneratedField::Status),
2433 "version" => Ok(GeneratedField::Version),
2434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2435 }
2436 }
2437 }
2438 deserializer.deserialize_identifier(GeneratedVisitor)
2439 }
2440 }
2441 struct GeneratedVisitor;
2442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2443 type Value = AlterSetSchemaResponse;
2444
2445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2446 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2447 }
2448
2449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2450 where
2451 V: serde::de::MapAccess<'de>,
2452 {
2453 let mut status__ = None;
2454 let mut version__ = None;
2455 while let Some(k) = map_.next_key()? {
2456 match k {
2457 GeneratedField::Status => {
2458 if status__.is_some() {
2459 return Err(serde::de::Error::duplicate_field("status"));
2460 }
2461 status__ = map_.next_value()?;
2462 }
2463 GeneratedField::Version => {
2464 if version__.is_some() {
2465 return Err(serde::de::Error::duplicate_field("version"));
2466 }
2467 version__ = map_.next_value()?;
2468 }
2469 }
2470 }
2471 Ok(AlterSetSchemaResponse {
2472 status: status__,
2473 version: version__,
2474 })
2475 }
2476 }
2477 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2478 }
2479}
2480impl serde::Serialize for AlterSourceRequest {
2481 #[allow(deprecated)]
2482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2483 where
2484 S: serde::Serializer,
2485 {
2486 use serde::ser::SerializeStruct;
2487 let mut len = 0;
2488 if self.source.is_some() {
2489 len += 1;
2490 }
2491 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2492 if let Some(v) = self.source.as_ref() {
2493 struct_ser.serialize_field("source", v)?;
2494 }
2495 struct_ser.end()
2496 }
2497}
2498impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2499 #[allow(deprecated)]
2500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2501 where
2502 D: serde::Deserializer<'de>,
2503 {
2504 const FIELDS: &[&str] = &[
2505 "source",
2506 ];
2507
2508 #[allow(clippy::enum_variant_names)]
2509 enum GeneratedField {
2510 Source,
2511 }
2512 impl<'de> serde::Deserialize<'de> for GeneratedField {
2513 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2514 where
2515 D: serde::Deserializer<'de>,
2516 {
2517 struct GeneratedVisitor;
2518
2519 impl serde::de::Visitor<'_> for GeneratedVisitor {
2520 type Value = GeneratedField;
2521
2522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2523 write!(formatter, "expected one of: {:?}", &FIELDS)
2524 }
2525
2526 #[allow(unused_variables)]
2527 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2528 where
2529 E: serde::de::Error,
2530 {
2531 match value {
2532 "source" => Ok(GeneratedField::Source),
2533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2534 }
2535 }
2536 }
2537 deserializer.deserialize_identifier(GeneratedVisitor)
2538 }
2539 }
2540 struct GeneratedVisitor;
2541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2542 type Value = AlterSourceRequest;
2543
2544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2545 formatter.write_str("struct ddl_service.AlterSourceRequest")
2546 }
2547
2548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2549 where
2550 V: serde::de::MapAccess<'de>,
2551 {
2552 let mut source__ = None;
2553 while let Some(k) = map_.next_key()? {
2554 match k {
2555 GeneratedField::Source => {
2556 if source__.is_some() {
2557 return Err(serde::de::Error::duplicate_field("source"));
2558 }
2559 source__ = map_.next_value()?;
2560 }
2561 }
2562 }
2563 Ok(AlterSourceRequest {
2564 source: source__,
2565 })
2566 }
2567 }
2568 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2569 }
2570}
2571impl serde::Serialize for AlterSourceResponse {
2572 #[allow(deprecated)]
2573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2574 where
2575 S: serde::Serializer,
2576 {
2577 use serde::ser::SerializeStruct;
2578 let mut len = 0;
2579 if self.status.is_some() {
2580 len += 1;
2581 }
2582 if self.version.is_some() {
2583 len += 1;
2584 }
2585 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2586 if let Some(v) = self.status.as_ref() {
2587 struct_ser.serialize_field("status", v)?;
2588 }
2589 if let Some(v) = self.version.as_ref() {
2590 struct_ser.serialize_field("version", v)?;
2591 }
2592 struct_ser.end()
2593 }
2594}
2595impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2596 #[allow(deprecated)]
2597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2598 where
2599 D: serde::Deserializer<'de>,
2600 {
2601 const FIELDS: &[&str] = &[
2602 "status",
2603 "version",
2604 ];
2605
2606 #[allow(clippy::enum_variant_names)]
2607 enum GeneratedField {
2608 Status,
2609 Version,
2610 }
2611 impl<'de> serde::Deserialize<'de> for GeneratedField {
2612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2613 where
2614 D: serde::Deserializer<'de>,
2615 {
2616 struct GeneratedVisitor;
2617
2618 impl serde::de::Visitor<'_> for GeneratedVisitor {
2619 type Value = GeneratedField;
2620
2621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2622 write!(formatter, "expected one of: {:?}", &FIELDS)
2623 }
2624
2625 #[allow(unused_variables)]
2626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2627 where
2628 E: serde::de::Error,
2629 {
2630 match value {
2631 "status" => Ok(GeneratedField::Status),
2632 "version" => Ok(GeneratedField::Version),
2633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2634 }
2635 }
2636 }
2637 deserializer.deserialize_identifier(GeneratedVisitor)
2638 }
2639 }
2640 struct GeneratedVisitor;
2641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2642 type Value = AlterSourceResponse;
2643
2644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2645 formatter.write_str("struct ddl_service.AlterSourceResponse")
2646 }
2647
2648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2649 where
2650 V: serde::de::MapAccess<'de>,
2651 {
2652 let mut status__ = None;
2653 let mut version__ = None;
2654 while let Some(k) = map_.next_key()? {
2655 match k {
2656 GeneratedField::Status => {
2657 if status__.is_some() {
2658 return Err(serde::de::Error::duplicate_field("status"));
2659 }
2660 status__ = map_.next_value()?;
2661 }
2662 GeneratedField::Version => {
2663 if version__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("version"));
2665 }
2666 version__ = map_.next_value()?;
2667 }
2668 }
2669 }
2670 Ok(AlterSourceResponse {
2671 status: status__,
2672 version: version__,
2673 })
2674 }
2675 }
2676 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2677 }
2678}
2679impl serde::Serialize for AlterStreamingJobConfigRequest {
2680 #[allow(deprecated)]
2681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2682 where
2683 S: serde::Serializer,
2684 {
2685 use serde::ser::SerializeStruct;
2686 let mut len = 0;
2687 if self.job_id != 0 {
2688 len += 1;
2689 }
2690 if !self.entries_to_add.is_empty() {
2691 len += 1;
2692 }
2693 if !self.keys_to_remove.is_empty() {
2694 len += 1;
2695 }
2696 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigRequest", len)?;
2697 if self.job_id != 0 {
2698 struct_ser.serialize_field("jobId", &self.job_id)?;
2699 }
2700 if !self.entries_to_add.is_empty() {
2701 struct_ser.serialize_field("entriesToAdd", &self.entries_to_add)?;
2702 }
2703 if !self.keys_to_remove.is_empty() {
2704 struct_ser.serialize_field("keysToRemove", &self.keys_to_remove)?;
2705 }
2706 struct_ser.end()
2707 }
2708}
2709impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigRequest {
2710 #[allow(deprecated)]
2711 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2712 where
2713 D: serde::Deserializer<'de>,
2714 {
2715 const FIELDS: &[&str] = &[
2716 "job_id",
2717 "jobId",
2718 "entries_to_add",
2719 "entriesToAdd",
2720 "keys_to_remove",
2721 "keysToRemove",
2722 ];
2723
2724 #[allow(clippy::enum_variant_names)]
2725 enum GeneratedField {
2726 JobId,
2727 EntriesToAdd,
2728 KeysToRemove,
2729 }
2730 impl<'de> serde::Deserialize<'de> for GeneratedField {
2731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2732 where
2733 D: serde::Deserializer<'de>,
2734 {
2735 struct GeneratedVisitor;
2736
2737 impl serde::de::Visitor<'_> for GeneratedVisitor {
2738 type Value = GeneratedField;
2739
2740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2741 write!(formatter, "expected one of: {:?}", &FIELDS)
2742 }
2743
2744 #[allow(unused_variables)]
2745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2746 where
2747 E: serde::de::Error,
2748 {
2749 match value {
2750 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2751 "entriesToAdd" | "entries_to_add" => Ok(GeneratedField::EntriesToAdd),
2752 "keysToRemove" | "keys_to_remove" => Ok(GeneratedField::KeysToRemove),
2753 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2754 }
2755 }
2756 }
2757 deserializer.deserialize_identifier(GeneratedVisitor)
2758 }
2759 }
2760 struct GeneratedVisitor;
2761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2762 type Value = AlterStreamingJobConfigRequest;
2763
2764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2765 formatter.write_str("struct ddl_service.AlterStreamingJobConfigRequest")
2766 }
2767
2768 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigRequest, V::Error>
2769 where
2770 V: serde::de::MapAccess<'de>,
2771 {
2772 let mut job_id__ = None;
2773 let mut entries_to_add__ = None;
2774 let mut keys_to_remove__ = None;
2775 while let Some(k) = map_.next_key()? {
2776 match k {
2777 GeneratedField::JobId => {
2778 if job_id__.is_some() {
2779 return Err(serde::de::Error::duplicate_field("jobId"));
2780 }
2781 job_id__ =
2782 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2783 ;
2784 }
2785 GeneratedField::EntriesToAdd => {
2786 if entries_to_add__.is_some() {
2787 return Err(serde::de::Error::duplicate_field("entriesToAdd"));
2788 }
2789 entries_to_add__ = Some(
2790 map_.next_value::<std::collections::HashMap<_, _>>()?
2791 );
2792 }
2793 GeneratedField::KeysToRemove => {
2794 if keys_to_remove__.is_some() {
2795 return Err(serde::de::Error::duplicate_field("keysToRemove"));
2796 }
2797 keys_to_remove__ = Some(map_.next_value()?);
2798 }
2799 }
2800 }
2801 Ok(AlterStreamingJobConfigRequest {
2802 job_id: job_id__.unwrap_or_default(),
2803 entries_to_add: entries_to_add__.unwrap_or_default(),
2804 keys_to_remove: keys_to_remove__.unwrap_or_default(),
2805 })
2806 }
2807 }
2808 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigRequest", FIELDS, GeneratedVisitor)
2809 }
2810}
2811impl serde::Serialize for AlterStreamingJobConfigResponse {
2812 #[allow(deprecated)]
2813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2814 where
2815 S: serde::Serializer,
2816 {
2817 use serde::ser::SerializeStruct;
2818 let len = 0;
2819 let struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigResponse", len)?;
2820 struct_ser.end()
2821 }
2822}
2823impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigResponse {
2824 #[allow(deprecated)]
2825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2826 where
2827 D: serde::Deserializer<'de>,
2828 {
2829 const FIELDS: &[&str] = &[
2830 ];
2831
2832 #[allow(clippy::enum_variant_names)]
2833 enum GeneratedField {
2834 }
2835 impl<'de> serde::Deserialize<'de> for GeneratedField {
2836 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2837 where
2838 D: serde::Deserializer<'de>,
2839 {
2840 struct GeneratedVisitor;
2841
2842 impl serde::de::Visitor<'_> for GeneratedVisitor {
2843 type Value = GeneratedField;
2844
2845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2846 write!(formatter, "expected one of: {:?}", &FIELDS)
2847 }
2848
2849 #[allow(unused_variables)]
2850 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2851 where
2852 E: serde::de::Error,
2853 {
2854 Err(serde::de::Error::unknown_field(value, FIELDS))
2855 }
2856 }
2857 deserializer.deserialize_identifier(GeneratedVisitor)
2858 }
2859 }
2860 struct GeneratedVisitor;
2861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2862 type Value = AlterStreamingJobConfigResponse;
2863
2864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2865 formatter.write_str("struct ddl_service.AlterStreamingJobConfigResponse")
2866 }
2867
2868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigResponse, V::Error>
2869 where
2870 V: serde::de::MapAccess<'de>,
2871 {
2872 while map_.next_key::<GeneratedField>()?.is_some() {
2873 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2874 }
2875 Ok(AlterStreamingJobConfigResponse {
2876 })
2877 }
2878 }
2879 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigResponse", FIELDS, GeneratedVisitor)
2880 }
2881}
2882impl serde::Serialize for AlterSubscriptionRetentionRequest {
2883 #[allow(deprecated)]
2884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2885 where
2886 S: serde::Serializer,
2887 {
2888 use serde::ser::SerializeStruct;
2889 let mut len = 0;
2890 if self.subscription_id != 0 {
2891 len += 1;
2892 }
2893 if self.retention_seconds != 0 {
2894 len += 1;
2895 }
2896 if !self.definition.is_empty() {
2897 len += 1;
2898 }
2899 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionRequest", len)?;
2900 if self.subscription_id != 0 {
2901 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
2902 }
2903 if self.retention_seconds != 0 {
2904 #[allow(clippy::needless_borrow)]
2905 #[allow(clippy::needless_borrows_for_generic_args)]
2906 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
2907 }
2908 if !self.definition.is_empty() {
2909 struct_ser.serialize_field("definition", &self.definition)?;
2910 }
2911 struct_ser.end()
2912 }
2913}
2914impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionRequest {
2915 #[allow(deprecated)]
2916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2917 where
2918 D: serde::Deserializer<'de>,
2919 {
2920 const FIELDS: &[&str] = &[
2921 "subscription_id",
2922 "subscriptionId",
2923 "retention_seconds",
2924 "retentionSeconds",
2925 "definition",
2926 ];
2927
2928 #[allow(clippy::enum_variant_names)]
2929 enum GeneratedField {
2930 SubscriptionId,
2931 RetentionSeconds,
2932 Definition,
2933 }
2934 impl<'de> serde::Deserialize<'de> for GeneratedField {
2935 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2936 where
2937 D: serde::Deserializer<'de>,
2938 {
2939 struct GeneratedVisitor;
2940
2941 impl serde::de::Visitor<'_> for GeneratedVisitor {
2942 type Value = GeneratedField;
2943
2944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2945 write!(formatter, "expected one of: {:?}", &FIELDS)
2946 }
2947
2948 #[allow(unused_variables)]
2949 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2950 where
2951 E: serde::de::Error,
2952 {
2953 match value {
2954 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2955 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
2956 "definition" => Ok(GeneratedField::Definition),
2957 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2958 }
2959 }
2960 }
2961 deserializer.deserialize_identifier(GeneratedVisitor)
2962 }
2963 }
2964 struct GeneratedVisitor;
2965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2966 type Value = AlterSubscriptionRetentionRequest;
2967
2968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2969 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionRequest")
2970 }
2971
2972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionRequest, V::Error>
2973 where
2974 V: serde::de::MapAccess<'de>,
2975 {
2976 let mut subscription_id__ = None;
2977 let mut retention_seconds__ = None;
2978 let mut definition__ = None;
2979 while let Some(k) = map_.next_key()? {
2980 match k {
2981 GeneratedField::SubscriptionId => {
2982 if subscription_id__.is_some() {
2983 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2984 }
2985 subscription_id__ =
2986 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2987 ;
2988 }
2989 GeneratedField::RetentionSeconds => {
2990 if retention_seconds__.is_some() {
2991 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
2992 }
2993 retention_seconds__ =
2994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2995 ;
2996 }
2997 GeneratedField::Definition => {
2998 if definition__.is_some() {
2999 return Err(serde::de::Error::duplicate_field("definition"));
3000 }
3001 definition__ = Some(map_.next_value()?);
3002 }
3003 }
3004 }
3005 Ok(AlterSubscriptionRetentionRequest {
3006 subscription_id: subscription_id__.unwrap_or_default(),
3007 retention_seconds: retention_seconds__.unwrap_or_default(),
3008 definition: definition__.unwrap_or_default(),
3009 })
3010 }
3011 }
3012 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionRequest", FIELDS, GeneratedVisitor)
3013 }
3014}
3015impl serde::Serialize for AlterSubscriptionRetentionResponse {
3016 #[allow(deprecated)]
3017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3018 where
3019 S: serde::Serializer,
3020 {
3021 use serde::ser::SerializeStruct;
3022 let mut len = 0;
3023 if self.status.is_some() {
3024 len += 1;
3025 }
3026 if self.version.is_some() {
3027 len += 1;
3028 }
3029 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionResponse", len)?;
3030 if let Some(v) = self.status.as_ref() {
3031 struct_ser.serialize_field("status", v)?;
3032 }
3033 if let Some(v) = self.version.as_ref() {
3034 struct_ser.serialize_field("version", v)?;
3035 }
3036 struct_ser.end()
3037 }
3038}
3039impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionResponse {
3040 #[allow(deprecated)]
3041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3042 where
3043 D: serde::Deserializer<'de>,
3044 {
3045 const FIELDS: &[&str] = &[
3046 "status",
3047 "version",
3048 ];
3049
3050 #[allow(clippy::enum_variant_names)]
3051 enum GeneratedField {
3052 Status,
3053 Version,
3054 }
3055 impl<'de> serde::Deserialize<'de> for GeneratedField {
3056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3057 where
3058 D: serde::Deserializer<'de>,
3059 {
3060 struct GeneratedVisitor;
3061
3062 impl serde::de::Visitor<'_> for GeneratedVisitor {
3063 type Value = GeneratedField;
3064
3065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3066 write!(formatter, "expected one of: {:?}", &FIELDS)
3067 }
3068
3069 #[allow(unused_variables)]
3070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3071 where
3072 E: serde::de::Error,
3073 {
3074 match value {
3075 "status" => Ok(GeneratedField::Status),
3076 "version" => Ok(GeneratedField::Version),
3077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3078 }
3079 }
3080 }
3081 deserializer.deserialize_identifier(GeneratedVisitor)
3082 }
3083 }
3084 struct GeneratedVisitor;
3085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3086 type Value = AlterSubscriptionRetentionResponse;
3087
3088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3089 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionResponse")
3090 }
3091
3092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionResponse, V::Error>
3093 where
3094 V: serde::de::MapAccess<'de>,
3095 {
3096 let mut status__ = None;
3097 let mut version__ = None;
3098 while let Some(k) = map_.next_key()? {
3099 match k {
3100 GeneratedField::Status => {
3101 if status__.is_some() {
3102 return Err(serde::de::Error::duplicate_field("status"));
3103 }
3104 status__ = map_.next_value()?;
3105 }
3106 GeneratedField::Version => {
3107 if version__.is_some() {
3108 return Err(serde::de::Error::duplicate_field("version"));
3109 }
3110 version__ = map_.next_value()?;
3111 }
3112 }
3113 }
3114 Ok(AlterSubscriptionRetentionResponse {
3115 status: status__,
3116 version: version__,
3117 })
3118 }
3119 }
3120 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionResponse", FIELDS, GeneratedVisitor)
3121 }
3122}
3123impl serde::Serialize for AlterSwapRenameRequest {
3124 #[allow(deprecated)]
3125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3126 where
3127 S: serde::Serializer,
3128 {
3129 use serde::ser::SerializeStruct;
3130 let mut len = 0;
3131 if self.object.is_some() {
3132 len += 1;
3133 }
3134 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
3135 if let Some(v) = self.object.as_ref() {
3136 match v {
3137 alter_swap_rename_request::Object::Schema(v) => {
3138 struct_ser.serialize_field("schema", v)?;
3139 }
3140 alter_swap_rename_request::Object::Table(v) => {
3141 struct_ser.serialize_field("table", v)?;
3142 }
3143 alter_swap_rename_request::Object::View(v) => {
3144 struct_ser.serialize_field("view", v)?;
3145 }
3146 alter_swap_rename_request::Object::Source(v) => {
3147 struct_ser.serialize_field("source", v)?;
3148 }
3149 alter_swap_rename_request::Object::Sink(v) => {
3150 struct_ser.serialize_field("sink", v)?;
3151 }
3152 alter_swap_rename_request::Object::Subscription(v) => {
3153 struct_ser.serialize_field("subscription", v)?;
3154 }
3155 }
3156 }
3157 struct_ser.end()
3158 }
3159}
3160impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
3161 #[allow(deprecated)]
3162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3163 where
3164 D: serde::Deserializer<'de>,
3165 {
3166 const FIELDS: &[&str] = &[
3167 "schema",
3168 "table",
3169 "view",
3170 "source",
3171 "sink",
3172 "subscription",
3173 ];
3174
3175 #[allow(clippy::enum_variant_names)]
3176 enum GeneratedField {
3177 Schema,
3178 Table,
3179 View,
3180 Source,
3181 Sink,
3182 Subscription,
3183 }
3184 impl<'de> serde::Deserialize<'de> for GeneratedField {
3185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3186 where
3187 D: serde::Deserializer<'de>,
3188 {
3189 struct GeneratedVisitor;
3190
3191 impl serde::de::Visitor<'_> for GeneratedVisitor {
3192 type Value = GeneratedField;
3193
3194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3195 write!(formatter, "expected one of: {:?}", &FIELDS)
3196 }
3197
3198 #[allow(unused_variables)]
3199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3200 where
3201 E: serde::de::Error,
3202 {
3203 match value {
3204 "schema" => Ok(GeneratedField::Schema),
3205 "table" => Ok(GeneratedField::Table),
3206 "view" => Ok(GeneratedField::View),
3207 "source" => Ok(GeneratedField::Source),
3208 "sink" => Ok(GeneratedField::Sink),
3209 "subscription" => Ok(GeneratedField::Subscription),
3210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3211 }
3212 }
3213 }
3214 deserializer.deserialize_identifier(GeneratedVisitor)
3215 }
3216 }
3217 struct GeneratedVisitor;
3218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3219 type Value = AlterSwapRenameRequest;
3220
3221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3222 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
3223 }
3224
3225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
3226 where
3227 V: serde::de::MapAccess<'de>,
3228 {
3229 let mut object__ = None;
3230 while let Some(k) = map_.next_key()? {
3231 match k {
3232 GeneratedField::Schema => {
3233 if object__.is_some() {
3234 return Err(serde::de::Error::duplicate_field("schema"));
3235 }
3236 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
3237;
3238 }
3239 GeneratedField::Table => {
3240 if object__.is_some() {
3241 return Err(serde::de::Error::duplicate_field("table"));
3242 }
3243 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
3244;
3245 }
3246 GeneratedField::View => {
3247 if object__.is_some() {
3248 return Err(serde::de::Error::duplicate_field("view"));
3249 }
3250 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
3251;
3252 }
3253 GeneratedField::Source => {
3254 if object__.is_some() {
3255 return Err(serde::de::Error::duplicate_field("source"));
3256 }
3257 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
3258;
3259 }
3260 GeneratedField::Sink => {
3261 if object__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("sink"));
3263 }
3264 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
3265;
3266 }
3267 GeneratedField::Subscription => {
3268 if object__.is_some() {
3269 return Err(serde::de::Error::duplicate_field("subscription"));
3270 }
3271 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
3272;
3273 }
3274 }
3275 }
3276 Ok(AlterSwapRenameRequest {
3277 object: object__,
3278 })
3279 }
3280 }
3281 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
3282 }
3283}
3284impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
3285 #[allow(deprecated)]
3286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3287 where
3288 S: serde::Serializer,
3289 {
3290 use serde::ser::SerializeStruct;
3291 let mut len = 0;
3292 if self.src_object_id != 0 {
3293 len += 1;
3294 }
3295 if self.dst_object_id != 0 {
3296 len += 1;
3297 }
3298 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
3299 if self.src_object_id != 0 {
3300 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
3301 }
3302 if self.dst_object_id != 0 {
3303 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
3304 }
3305 struct_ser.end()
3306 }
3307}
3308impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
3309 #[allow(deprecated)]
3310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3311 where
3312 D: serde::Deserializer<'de>,
3313 {
3314 const FIELDS: &[&str] = &[
3315 "src_object_id",
3316 "srcObjectId",
3317 "dst_object_id",
3318 "dstObjectId",
3319 ];
3320
3321 #[allow(clippy::enum_variant_names)]
3322 enum GeneratedField {
3323 SrcObjectId,
3324 DstObjectId,
3325 }
3326 impl<'de> serde::Deserialize<'de> for GeneratedField {
3327 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3328 where
3329 D: serde::Deserializer<'de>,
3330 {
3331 struct GeneratedVisitor;
3332
3333 impl serde::de::Visitor<'_> for GeneratedVisitor {
3334 type Value = GeneratedField;
3335
3336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3337 write!(formatter, "expected one of: {:?}", &FIELDS)
3338 }
3339
3340 #[allow(unused_variables)]
3341 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3342 where
3343 E: serde::de::Error,
3344 {
3345 match value {
3346 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
3347 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
3348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3349 }
3350 }
3351 }
3352 deserializer.deserialize_identifier(GeneratedVisitor)
3353 }
3354 }
3355 struct GeneratedVisitor;
3356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3357 type Value = alter_swap_rename_request::ObjectNameSwapPair;
3358
3359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3360 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
3361 }
3362
3363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
3364 where
3365 V: serde::de::MapAccess<'de>,
3366 {
3367 let mut src_object_id__ = None;
3368 let mut dst_object_id__ = None;
3369 while let Some(k) = map_.next_key()? {
3370 match k {
3371 GeneratedField::SrcObjectId => {
3372 if src_object_id__.is_some() {
3373 return Err(serde::de::Error::duplicate_field("srcObjectId"));
3374 }
3375 src_object_id__ =
3376 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3377 ;
3378 }
3379 GeneratedField::DstObjectId => {
3380 if dst_object_id__.is_some() {
3381 return Err(serde::de::Error::duplicate_field("dstObjectId"));
3382 }
3383 dst_object_id__ =
3384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3385 ;
3386 }
3387 }
3388 }
3389 Ok(alter_swap_rename_request::ObjectNameSwapPair {
3390 src_object_id: src_object_id__.unwrap_or_default(),
3391 dst_object_id: dst_object_id__.unwrap_or_default(),
3392 })
3393 }
3394 }
3395 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
3396 }
3397}
3398impl serde::Serialize for AlterSwapRenameResponse {
3399 #[allow(deprecated)]
3400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3401 where
3402 S: serde::Serializer,
3403 {
3404 use serde::ser::SerializeStruct;
3405 let mut len = 0;
3406 if self.status.is_some() {
3407 len += 1;
3408 }
3409 if self.version.is_some() {
3410 len += 1;
3411 }
3412 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
3413 if let Some(v) = self.status.as_ref() {
3414 struct_ser.serialize_field("status", v)?;
3415 }
3416 if let Some(v) = self.version.as_ref() {
3417 struct_ser.serialize_field("version", v)?;
3418 }
3419 struct_ser.end()
3420 }
3421}
3422impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
3423 #[allow(deprecated)]
3424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3425 where
3426 D: serde::Deserializer<'de>,
3427 {
3428 const FIELDS: &[&str] = &[
3429 "status",
3430 "version",
3431 ];
3432
3433 #[allow(clippy::enum_variant_names)]
3434 enum GeneratedField {
3435 Status,
3436 Version,
3437 }
3438 impl<'de> serde::Deserialize<'de> for GeneratedField {
3439 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3440 where
3441 D: serde::Deserializer<'de>,
3442 {
3443 struct GeneratedVisitor;
3444
3445 impl serde::de::Visitor<'_> for GeneratedVisitor {
3446 type Value = GeneratedField;
3447
3448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3449 write!(formatter, "expected one of: {:?}", &FIELDS)
3450 }
3451
3452 #[allow(unused_variables)]
3453 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3454 where
3455 E: serde::de::Error,
3456 {
3457 match value {
3458 "status" => Ok(GeneratedField::Status),
3459 "version" => Ok(GeneratedField::Version),
3460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3461 }
3462 }
3463 }
3464 deserializer.deserialize_identifier(GeneratedVisitor)
3465 }
3466 }
3467 struct GeneratedVisitor;
3468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3469 type Value = AlterSwapRenameResponse;
3470
3471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3472 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
3473 }
3474
3475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
3476 where
3477 V: serde::de::MapAccess<'de>,
3478 {
3479 let mut status__ = None;
3480 let mut version__ = None;
3481 while let Some(k) = map_.next_key()? {
3482 match k {
3483 GeneratedField::Status => {
3484 if status__.is_some() {
3485 return Err(serde::de::Error::duplicate_field("status"));
3486 }
3487 status__ = map_.next_value()?;
3488 }
3489 GeneratedField::Version => {
3490 if version__.is_some() {
3491 return Err(serde::de::Error::duplicate_field("version"));
3492 }
3493 version__ = map_.next_value()?;
3494 }
3495 }
3496 }
3497 Ok(AlterSwapRenameResponse {
3498 status: status__,
3499 version: version__,
3500 })
3501 }
3502 }
3503 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
3504 }
3505}
3506impl serde::Serialize for AutoSchemaChangeRequest {
3507 #[allow(deprecated)]
3508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3509 where
3510 S: serde::Serializer,
3511 {
3512 use serde::ser::SerializeStruct;
3513 let mut len = 0;
3514 if self.schema_change.is_some() {
3515 len += 1;
3516 }
3517 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
3518 if let Some(v) = self.schema_change.as_ref() {
3519 struct_ser.serialize_field("schemaChange", v)?;
3520 }
3521 struct_ser.end()
3522 }
3523}
3524impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
3525 #[allow(deprecated)]
3526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3527 where
3528 D: serde::Deserializer<'de>,
3529 {
3530 const FIELDS: &[&str] = &[
3531 "schema_change",
3532 "schemaChange",
3533 ];
3534
3535 #[allow(clippy::enum_variant_names)]
3536 enum GeneratedField {
3537 SchemaChange,
3538 }
3539 impl<'de> serde::Deserialize<'de> for GeneratedField {
3540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3541 where
3542 D: serde::Deserializer<'de>,
3543 {
3544 struct GeneratedVisitor;
3545
3546 impl serde::de::Visitor<'_> for GeneratedVisitor {
3547 type Value = GeneratedField;
3548
3549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3550 write!(formatter, "expected one of: {:?}", &FIELDS)
3551 }
3552
3553 #[allow(unused_variables)]
3554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3555 where
3556 E: serde::de::Error,
3557 {
3558 match value {
3559 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
3560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3561 }
3562 }
3563 }
3564 deserializer.deserialize_identifier(GeneratedVisitor)
3565 }
3566 }
3567 struct GeneratedVisitor;
3568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3569 type Value = AutoSchemaChangeRequest;
3570
3571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3572 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
3573 }
3574
3575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
3576 where
3577 V: serde::de::MapAccess<'de>,
3578 {
3579 let mut schema_change__ = None;
3580 while let Some(k) = map_.next_key()? {
3581 match k {
3582 GeneratedField::SchemaChange => {
3583 if schema_change__.is_some() {
3584 return Err(serde::de::Error::duplicate_field("schemaChange"));
3585 }
3586 schema_change__ = map_.next_value()?;
3587 }
3588 }
3589 }
3590 Ok(AutoSchemaChangeRequest {
3591 schema_change: schema_change__,
3592 })
3593 }
3594 }
3595 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
3596 }
3597}
3598impl serde::Serialize for AutoSchemaChangeResponse {
3599 #[allow(deprecated)]
3600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3601 where
3602 S: serde::Serializer,
3603 {
3604 use serde::ser::SerializeStruct;
3605 let len = 0;
3606 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
3607 struct_ser.end()
3608 }
3609}
3610impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
3611 #[allow(deprecated)]
3612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3613 where
3614 D: serde::Deserializer<'de>,
3615 {
3616 const FIELDS: &[&str] = &[
3617 ];
3618
3619 #[allow(clippy::enum_variant_names)]
3620 enum GeneratedField {
3621 }
3622 impl<'de> serde::Deserialize<'de> for GeneratedField {
3623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3624 where
3625 D: serde::Deserializer<'de>,
3626 {
3627 struct GeneratedVisitor;
3628
3629 impl serde::de::Visitor<'_> for GeneratedVisitor {
3630 type Value = GeneratedField;
3631
3632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3633 write!(formatter, "expected one of: {:?}", &FIELDS)
3634 }
3635
3636 #[allow(unused_variables)]
3637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3638 where
3639 E: serde::de::Error,
3640 {
3641 Err(serde::de::Error::unknown_field(value, FIELDS))
3642 }
3643 }
3644 deserializer.deserialize_identifier(GeneratedVisitor)
3645 }
3646 }
3647 struct GeneratedVisitor;
3648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3649 type Value = AutoSchemaChangeResponse;
3650
3651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3652 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
3653 }
3654
3655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
3656 where
3657 V: serde::de::MapAccess<'de>,
3658 {
3659 while map_.next_key::<GeneratedField>()?.is_some() {
3660 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3661 }
3662 Ok(AutoSchemaChangeResponse {
3663 })
3664 }
3665 }
3666 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
3667 }
3668}
3669impl serde::Serialize for BackfillType {
3670 #[allow(deprecated)]
3671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3672 where
3673 S: serde::Serializer,
3674 {
3675 let variant = match self {
3676 Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
3677 Self::NormalBackfill => "NORMAL_BACKFILL",
3678 Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
3679 };
3680 serializer.serialize_str(variant)
3681 }
3682}
3683impl<'de> serde::Deserialize<'de> for BackfillType {
3684 #[allow(deprecated)]
3685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3686 where
3687 D: serde::Deserializer<'de>,
3688 {
3689 const FIELDS: &[&str] = &[
3690 "BACKFILL_TYPE_UNSPECIFIED",
3691 "NORMAL_BACKFILL",
3692 "SNAPSHOT_BACKFILL",
3693 ];
3694
3695 struct GeneratedVisitor;
3696
3697 impl serde::de::Visitor<'_> for GeneratedVisitor {
3698 type Value = BackfillType;
3699
3700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3701 write!(formatter, "expected one of: {:?}", &FIELDS)
3702 }
3703
3704 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3705 where
3706 E: serde::de::Error,
3707 {
3708 i32::try_from(v)
3709 .ok()
3710 .and_then(|x| x.try_into().ok())
3711 .ok_or_else(|| {
3712 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3713 })
3714 }
3715
3716 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3717 where
3718 E: serde::de::Error,
3719 {
3720 i32::try_from(v)
3721 .ok()
3722 .and_then(|x| x.try_into().ok())
3723 .ok_or_else(|| {
3724 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3725 })
3726 }
3727
3728 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3729 where
3730 E: serde::de::Error,
3731 {
3732 match value {
3733 "BACKFILL_TYPE_UNSPECIFIED" => Ok(BackfillType::Unspecified),
3734 "NORMAL_BACKFILL" => Ok(BackfillType::NormalBackfill),
3735 "SNAPSHOT_BACKFILL" => Ok(BackfillType::SnapshotBackfill),
3736 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3737 }
3738 }
3739 }
3740 deserializer.deserialize_any(GeneratedVisitor)
3741 }
3742}
3743impl serde::Serialize for CommentOnRequest {
3744 #[allow(deprecated)]
3745 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3746 where
3747 S: serde::Serializer,
3748 {
3749 use serde::ser::SerializeStruct;
3750 let mut len = 0;
3751 if self.comment.is_some() {
3752 len += 1;
3753 }
3754 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
3755 if let Some(v) = self.comment.as_ref() {
3756 struct_ser.serialize_field("comment", v)?;
3757 }
3758 struct_ser.end()
3759 }
3760}
3761impl<'de> serde::Deserialize<'de> for CommentOnRequest {
3762 #[allow(deprecated)]
3763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3764 where
3765 D: serde::Deserializer<'de>,
3766 {
3767 const FIELDS: &[&str] = &[
3768 "comment",
3769 ];
3770
3771 #[allow(clippy::enum_variant_names)]
3772 enum GeneratedField {
3773 Comment,
3774 }
3775 impl<'de> serde::Deserialize<'de> for GeneratedField {
3776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3777 where
3778 D: serde::Deserializer<'de>,
3779 {
3780 struct GeneratedVisitor;
3781
3782 impl serde::de::Visitor<'_> for GeneratedVisitor {
3783 type Value = GeneratedField;
3784
3785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3786 write!(formatter, "expected one of: {:?}", &FIELDS)
3787 }
3788
3789 #[allow(unused_variables)]
3790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3791 where
3792 E: serde::de::Error,
3793 {
3794 match value {
3795 "comment" => Ok(GeneratedField::Comment),
3796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3797 }
3798 }
3799 }
3800 deserializer.deserialize_identifier(GeneratedVisitor)
3801 }
3802 }
3803 struct GeneratedVisitor;
3804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3805 type Value = CommentOnRequest;
3806
3807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3808 formatter.write_str("struct ddl_service.CommentOnRequest")
3809 }
3810
3811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
3812 where
3813 V: serde::de::MapAccess<'de>,
3814 {
3815 let mut comment__ = None;
3816 while let Some(k) = map_.next_key()? {
3817 match k {
3818 GeneratedField::Comment => {
3819 if comment__.is_some() {
3820 return Err(serde::de::Error::duplicate_field("comment"));
3821 }
3822 comment__ = map_.next_value()?;
3823 }
3824 }
3825 }
3826 Ok(CommentOnRequest {
3827 comment: comment__,
3828 })
3829 }
3830 }
3831 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
3832 }
3833}
3834impl serde::Serialize for CommentOnResponse {
3835 #[allow(deprecated)]
3836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3837 where
3838 S: serde::Serializer,
3839 {
3840 use serde::ser::SerializeStruct;
3841 let mut len = 0;
3842 if self.status.is_some() {
3843 len += 1;
3844 }
3845 if self.version.is_some() {
3846 len += 1;
3847 }
3848 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
3849 if let Some(v) = self.status.as_ref() {
3850 struct_ser.serialize_field("status", v)?;
3851 }
3852 if let Some(v) = self.version.as_ref() {
3853 struct_ser.serialize_field("version", v)?;
3854 }
3855 struct_ser.end()
3856 }
3857}
3858impl<'de> serde::Deserialize<'de> for CommentOnResponse {
3859 #[allow(deprecated)]
3860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3861 where
3862 D: serde::Deserializer<'de>,
3863 {
3864 const FIELDS: &[&str] = &[
3865 "status",
3866 "version",
3867 ];
3868
3869 #[allow(clippy::enum_variant_names)]
3870 enum GeneratedField {
3871 Status,
3872 Version,
3873 }
3874 impl<'de> serde::Deserialize<'de> for GeneratedField {
3875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3876 where
3877 D: serde::Deserializer<'de>,
3878 {
3879 struct GeneratedVisitor;
3880
3881 impl serde::de::Visitor<'_> for GeneratedVisitor {
3882 type Value = GeneratedField;
3883
3884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3885 write!(formatter, "expected one of: {:?}", &FIELDS)
3886 }
3887
3888 #[allow(unused_variables)]
3889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3890 where
3891 E: serde::de::Error,
3892 {
3893 match value {
3894 "status" => Ok(GeneratedField::Status),
3895 "version" => Ok(GeneratedField::Version),
3896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3897 }
3898 }
3899 }
3900 deserializer.deserialize_identifier(GeneratedVisitor)
3901 }
3902 }
3903 struct GeneratedVisitor;
3904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3905 type Value = CommentOnResponse;
3906
3907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3908 formatter.write_str("struct ddl_service.CommentOnResponse")
3909 }
3910
3911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
3912 where
3913 V: serde::de::MapAccess<'de>,
3914 {
3915 let mut status__ = None;
3916 let mut version__ = None;
3917 while let Some(k) = map_.next_key()? {
3918 match k {
3919 GeneratedField::Status => {
3920 if status__.is_some() {
3921 return Err(serde::de::Error::duplicate_field("status"));
3922 }
3923 status__ = map_.next_value()?;
3924 }
3925 GeneratedField::Version => {
3926 if version__.is_some() {
3927 return Err(serde::de::Error::duplicate_field("version"));
3928 }
3929 version__ = map_.next_value()?;
3930 }
3931 }
3932 }
3933 Ok(CommentOnResponse {
3934 status: status__,
3935 version: version__,
3936 })
3937 }
3938 }
3939 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
3940 }
3941}
3942impl serde::Serialize for CompactIcebergTableRequest {
3943 #[allow(deprecated)]
3944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3945 where
3946 S: serde::Serializer,
3947 {
3948 use serde::ser::SerializeStruct;
3949 let mut len = 0;
3950 if self.sink_id != 0 {
3951 len += 1;
3952 }
3953 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
3954 if self.sink_id != 0 {
3955 struct_ser.serialize_field("sinkId", &self.sink_id)?;
3956 }
3957 struct_ser.end()
3958 }
3959}
3960impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
3961 #[allow(deprecated)]
3962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3963 where
3964 D: serde::Deserializer<'de>,
3965 {
3966 const FIELDS: &[&str] = &[
3967 "sink_id",
3968 "sinkId",
3969 ];
3970
3971 #[allow(clippy::enum_variant_names)]
3972 enum GeneratedField {
3973 SinkId,
3974 }
3975 impl<'de> serde::Deserialize<'de> for GeneratedField {
3976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3977 where
3978 D: serde::Deserializer<'de>,
3979 {
3980 struct GeneratedVisitor;
3981
3982 impl serde::de::Visitor<'_> for GeneratedVisitor {
3983 type Value = GeneratedField;
3984
3985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3986 write!(formatter, "expected one of: {:?}", &FIELDS)
3987 }
3988
3989 #[allow(unused_variables)]
3990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3991 where
3992 E: serde::de::Error,
3993 {
3994 match value {
3995 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
3996 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3997 }
3998 }
3999 }
4000 deserializer.deserialize_identifier(GeneratedVisitor)
4001 }
4002 }
4003 struct GeneratedVisitor;
4004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4005 type Value = CompactIcebergTableRequest;
4006
4007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4008 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
4009 }
4010
4011 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
4012 where
4013 V: serde::de::MapAccess<'de>,
4014 {
4015 let mut sink_id__ = None;
4016 while let Some(k) = map_.next_key()? {
4017 match k {
4018 GeneratedField::SinkId => {
4019 if sink_id__.is_some() {
4020 return Err(serde::de::Error::duplicate_field("sinkId"));
4021 }
4022 sink_id__ =
4023 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4024 ;
4025 }
4026 }
4027 }
4028 Ok(CompactIcebergTableRequest {
4029 sink_id: sink_id__.unwrap_or_default(),
4030 })
4031 }
4032 }
4033 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
4034 }
4035}
4036impl serde::Serialize for CompactIcebergTableResponse {
4037 #[allow(deprecated)]
4038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4039 where
4040 S: serde::Serializer,
4041 {
4042 use serde::ser::SerializeStruct;
4043 let mut len = 0;
4044 if self.status.is_some() {
4045 len += 1;
4046 }
4047 if self.task_id != 0 {
4048 len += 1;
4049 }
4050 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
4051 if let Some(v) = self.status.as_ref() {
4052 struct_ser.serialize_field("status", v)?;
4053 }
4054 if self.task_id != 0 {
4055 #[allow(clippy::needless_borrow)]
4056 #[allow(clippy::needless_borrows_for_generic_args)]
4057 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
4058 }
4059 struct_ser.end()
4060 }
4061}
4062impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
4063 #[allow(deprecated)]
4064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4065 where
4066 D: serde::Deserializer<'de>,
4067 {
4068 const FIELDS: &[&str] = &[
4069 "status",
4070 "task_id",
4071 "taskId",
4072 ];
4073
4074 #[allow(clippy::enum_variant_names)]
4075 enum GeneratedField {
4076 Status,
4077 TaskId,
4078 }
4079 impl<'de> serde::Deserialize<'de> for GeneratedField {
4080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4081 where
4082 D: serde::Deserializer<'de>,
4083 {
4084 struct GeneratedVisitor;
4085
4086 impl serde::de::Visitor<'_> for GeneratedVisitor {
4087 type Value = GeneratedField;
4088
4089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090 write!(formatter, "expected one of: {:?}", &FIELDS)
4091 }
4092
4093 #[allow(unused_variables)]
4094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4095 where
4096 E: serde::de::Error,
4097 {
4098 match value {
4099 "status" => Ok(GeneratedField::Status),
4100 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
4101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4102 }
4103 }
4104 }
4105 deserializer.deserialize_identifier(GeneratedVisitor)
4106 }
4107 }
4108 struct GeneratedVisitor;
4109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4110 type Value = CompactIcebergTableResponse;
4111
4112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4113 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
4114 }
4115
4116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
4117 where
4118 V: serde::de::MapAccess<'de>,
4119 {
4120 let mut status__ = None;
4121 let mut task_id__ = None;
4122 while let Some(k) = map_.next_key()? {
4123 match k {
4124 GeneratedField::Status => {
4125 if status__.is_some() {
4126 return Err(serde::de::Error::duplicate_field("status"));
4127 }
4128 status__ = map_.next_value()?;
4129 }
4130 GeneratedField::TaskId => {
4131 if task_id__.is_some() {
4132 return Err(serde::de::Error::duplicate_field("taskId"));
4133 }
4134 task_id__ =
4135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4136 ;
4137 }
4138 }
4139 }
4140 Ok(CompactIcebergTableResponse {
4141 status: status__,
4142 task_id: task_id__.unwrap_or_default(),
4143 })
4144 }
4145 }
4146 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
4147 }
4148}
4149impl serde::Serialize for CreateConnectionRequest {
4150 #[allow(deprecated)]
4151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4152 where
4153 S: serde::Serializer,
4154 {
4155 use serde::ser::SerializeStruct;
4156 let mut len = 0;
4157 if !self.name.is_empty() {
4158 len += 1;
4159 }
4160 if self.database_id != 0 {
4161 len += 1;
4162 }
4163 if self.schema_id != 0 {
4164 len += 1;
4165 }
4166 if self.owner_id != 0 {
4167 len += 1;
4168 }
4169 if self.payload.is_some() {
4170 len += 1;
4171 }
4172 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
4173 if !self.name.is_empty() {
4174 struct_ser.serialize_field("name", &self.name)?;
4175 }
4176 if self.database_id != 0 {
4177 struct_ser.serialize_field("databaseId", &self.database_id)?;
4178 }
4179 if self.schema_id != 0 {
4180 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4181 }
4182 if self.owner_id != 0 {
4183 struct_ser.serialize_field("ownerId", &self.owner_id)?;
4184 }
4185 if let Some(v) = self.payload.as_ref() {
4186 match v {
4187 create_connection_request::Payload::PrivateLink(v) => {
4188 struct_ser.serialize_field("privateLink", v)?;
4189 }
4190 create_connection_request::Payload::ConnectionParams(v) => {
4191 struct_ser.serialize_field("connectionParams", v)?;
4192 }
4193 }
4194 }
4195 struct_ser.end()
4196 }
4197}
4198impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
4199 #[allow(deprecated)]
4200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4201 where
4202 D: serde::Deserializer<'de>,
4203 {
4204 const FIELDS: &[&str] = &[
4205 "name",
4206 "database_id",
4207 "databaseId",
4208 "schema_id",
4209 "schemaId",
4210 "owner_id",
4211 "ownerId",
4212 "private_link",
4213 "privateLink",
4214 "connection_params",
4215 "connectionParams",
4216 ];
4217
4218 #[allow(clippy::enum_variant_names)]
4219 enum GeneratedField {
4220 Name,
4221 DatabaseId,
4222 SchemaId,
4223 OwnerId,
4224 PrivateLink,
4225 ConnectionParams,
4226 }
4227 impl<'de> serde::Deserialize<'de> for GeneratedField {
4228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4229 where
4230 D: serde::Deserializer<'de>,
4231 {
4232 struct GeneratedVisitor;
4233
4234 impl serde::de::Visitor<'_> for GeneratedVisitor {
4235 type Value = GeneratedField;
4236
4237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4238 write!(formatter, "expected one of: {:?}", &FIELDS)
4239 }
4240
4241 #[allow(unused_variables)]
4242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4243 where
4244 E: serde::de::Error,
4245 {
4246 match value {
4247 "name" => Ok(GeneratedField::Name),
4248 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4249 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4250 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
4251 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
4252 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
4253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4254 }
4255 }
4256 }
4257 deserializer.deserialize_identifier(GeneratedVisitor)
4258 }
4259 }
4260 struct GeneratedVisitor;
4261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4262 type Value = CreateConnectionRequest;
4263
4264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4265 formatter.write_str("struct ddl_service.CreateConnectionRequest")
4266 }
4267
4268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
4269 where
4270 V: serde::de::MapAccess<'de>,
4271 {
4272 let mut name__ = None;
4273 let mut database_id__ = None;
4274 let mut schema_id__ = None;
4275 let mut owner_id__ = None;
4276 let mut payload__ = None;
4277 while let Some(k) = map_.next_key()? {
4278 match k {
4279 GeneratedField::Name => {
4280 if name__.is_some() {
4281 return Err(serde::de::Error::duplicate_field("name"));
4282 }
4283 name__ = Some(map_.next_value()?);
4284 }
4285 GeneratedField::DatabaseId => {
4286 if database_id__.is_some() {
4287 return Err(serde::de::Error::duplicate_field("databaseId"));
4288 }
4289 database_id__ =
4290 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4291 ;
4292 }
4293 GeneratedField::SchemaId => {
4294 if schema_id__.is_some() {
4295 return Err(serde::de::Error::duplicate_field("schemaId"));
4296 }
4297 schema_id__ =
4298 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4299 ;
4300 }
4301 GeneratedField::OwnerId => {
4302 if owner_id__.is_some() {
4303 return Err(serde::de::Error::duplicate_field("ownerId"));
4304 }
4305 owner_id__ =
4306 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4307 ;
4308 }
4309 GeneratedField::PrivateLink => {
4310 if payload__.is_some() {
4311 return Err(serde::de::Error::duplicate_field("privateLink"));
4312 }
4313 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
4314;
4315 }
4316 GeneratedField::ConnectionParams => {
4317 if payload__.is_some() {
4318 return Err(serde::de::Error::duplicate_field("connectionParams"));
4319 }
4320 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
4321;
4322 }
4323 }
4324 }
4325 Ok(CreateConnectionRequest {
4326 name: name__.unwrap_or_default(),
4327 database_id: database_id__.unwrap_or_default(),
4328 schema_id: schema_id__.unwrap_or_default(),
4329 owner_id: owner_id__.unwrap_or_default(),
4330 payload: payload__,
4331 })
4332 }
4333 }
4334 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
4335 }
4336}
4337impl serde::Serialize for create_connection_request::PrivateLink {
4338 #[allow(deprecated)]
4339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4340 where
4341 S: serde::Serializer,
4342 {
4343 use serde::ser::SerializeStruct;
4344 let mut len = 0;
4345 if self.provider != 0 {
4346 len += 1;
4347 }
4348 if !self.service_name.is_empty() {
4349 len += 1;
4350 }
4351 if self.tags.is_some() {
4352 len += 1;
4353 }
4354 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
4355 if self.provider != 0 {
4356 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
4357 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
4358 struct_ser.serialize_field("provider", &v)?;
4359 }
4360 if !self.service_name.is_empty() {
4361 struct_ser.serialize_field("serviceName", &self.service_name)?;
4362 }
4363 if let Some(v) = self.tags.as_ref() {
4364 struct_ser.serialize_field("tags", v)?;
4365 }
4366 struct_ser.end()
4367 }
4368}
4369impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
4370 #[allow(deprecated)]
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 const FIELDS: &[&str] = &[
4376 "provider",
4377 "service_name",
4378 "serviceName",
4379 "tags",
4380 ];
4381
4382 #[allow(clippy::enum_variant_names)]
4383 enum GeneratedField {
4384 Provider,
4385 ServiceName,
4386 Tags,
4387 }
4388 impl<'de> serde::Deserialize<'de> for GeneratedField {
4389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4390 where
4391 D: serde::Deserializer<'de>,
4392 {
4393 struct GeneratedVisitor;
4394
4395 impl serde::de::Visitor<'_> for GeneratedVisitor {
4396 type Value = GeneratedField;
4397
4398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4399 write!(formatter, "expected one of: {:?}", &FIELDS)
4400 }
4401
4402 #[allow(unused_variables)]
4403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4404 where
4405 E: serde::de::Error,
4406 {
4407 match value {
4408 "provider" => Ok(GeneratedField::Provider),
4409 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
4410 "tags" => Ok(GeneratedField::Tags),
4411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4412 }
4413 }
4414 }
4415 deserializer.deserialize_identifier(GeneratedVisitor)
4416 }
4417 }
4418 struct GeneratedVisitor;
4419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4420 type Value = create_connection_request::PrivateLink;
4421
4422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4423 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
4424 }
4425
4426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
4427 where
4428 V: serde::de::MapAccess<'de>,
4429 {
4430 let mut provider__ = None;
4431 let mut service_name__ = None;
4432 let mut tags__ = None;
4433 while let Some(k) = map_.next_key()? {
4434 match k {
4435 GeneratedField::Provider => {
4436 if provider__.is_some() {
4437 return Err(serde::de::Error::duplicate_field("provider"));
4438 }
4439 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
4440 }
4441 GeneratedField::ServiceName => {
4442 if service_name__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("serviceName"));
4444 }
4445 service_name__ = Some(map_.next_value()?);
4446 }
4447 GeneratedField::Tags => {
4448 if tags__.is_some() {
4449 return Err(serde::de::Error::duplicate_field("tags"));
4450 }
4451 tags__ = map_.next_value()?;
4452 }
4453 }
4454 }
4455 Ok(create_connection_request::PrivateLink {
4456 provider: provider__.unwrap_or_default(),
4457 service_name: service_name__.unwrap_or_default(),
4458 tags: tags__,
4459 })
4460 }
4461 }
4462 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
4463 }
4464}
4465impl serde::Serialize for CreateConnectionResponse {
4466 #[allow(deprecated)]
4467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4468 where
4469 S: serde::Serializer,
4470 {
4471 use serde::ser::SerializeStruct;
4472 let mut len = 0;
4473 if self.version.is_some() {
4474 len += 1;
4475 }
4476 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
4477 if let Some(v) = self.version.as_ref() {
4478 struct_ser.serialize_field("version", v)?;
4479 }
4480 struct_ser.end()
4481 }
4482}
4483impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
4484 #[allow(deprecated)]
4485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4486 where
4487 D: serde::Deserializer<'de>,
4488 {
4489 const FIELDS: &[&str] = &[
4490 "version",
4491 ];
4492
4493 #[allow(clippy::enum_variant_names)]
4494 enum GeneratedField {
4495 Version,
4496 }
4497 impl<'de> serde::Deserialize<'de> for GeneratedField {
4498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4499 where
4500 D: serde::Deserializer<'de>,
4501 {
4502 struct GeneratedVisitor;
4503
4504 impl serde::de::Visitor<'_> for GeneratedVisitor {
4505 type Value = GeneratedField;
4506
4507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4508 write!(formatter, "expected one of: {:?}", &FIELDS)
4509 }
4510
4511 #[allow(unused_variables)]
4512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4513 where
4514 E: serde::de::Error,
4515 {
4516 match value {
4517 "version" => Ok(GeneratedField::Version),
4518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4519 }
4520 }
4521 }
4522 deserializer.deserialize_identifier(GeneratedVisitor)
4523 }
4524 }
4525 struct GeneratedVisitor;
4526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4527 type Value = CreateConnectionResponse;
4528
4529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4530 formatter.write_str("struct ddl_service.CreateConnectionResponse")
4531 }
4532
4533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
4534 where
4535 V: serde::de::MapAccess<'de>,
4536 {
4537 let mut version__ = None;
4538 while let Some(k) = map_.next_key()? {
4539 match k {
4540 GeneratedField::Version => {
4541 if version__.is_some() {
4542 return Err(serde::de::Error::duplicate_field("version"));
4543 }
4544 version__ = map_.next_value()?;
4545 }
4546 }
4547 }
4548 Ok(CreateConnectionResponse {
4549 version: version__,
4550 })
4551 }
4552 }
4553 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
4554 }
4555}
4556impl serde::Serialize for CreateDatabaseRequest {
4557 #[allow(deprecated)]
4558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4559 where
4560 S: serde::Serializer,
4561 {
4562 use serde::ser::SerializeStruct;
4563 let mut len = 0;
4564 if self.db.is_some() {
4565 len += 1;
4566 }
4567 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
4568 if let Some(v) = self.db.as_ref() {
4569 struct_ser.serialize_field("db", v)?;
4570 }
4571 struct_ser.end()
4572 }
4573}
4574impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
4575 #[allow(deprecated)]
4576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4577 where
4578 D: serde::Deserializer<'de>,
4579 {
4580 const FIELDS: &[&str] = &[
4581 "db",
4582 ];
4583
4584 #[allow(clippy::enum_variant_names)]
4585 enum GeneratedField {
4586 Db,
4587 }
4588 impl<'de> serde::Deserialize<'de> for GeneratedField {
4589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4590 where
4591 D: serde::Deserializer<'de>,
4592 {
4593 struct GeneratedVisitor;
4594
4595 impl serde::de::Visitor<'_> for GeneratedVisitor {
4596 type Value = GeneratedField;
4597
4598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4599 write!(formatter, "expected one of: {:?}", &FIELDS)
4600 }
4601
4602 #[allow(unused_variables)]
4603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4604 where
4605 E: serde::de::Error,
4606 {
4607 match value {
4608 "db" => Ok(GeneratedField::Db),
4609 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4610 }
4611 }
4612 }
4613 deserializer.deserialize_identifier(GeneratedVisitor)
4614 }
4615 }
4616 struct GeneratedVisitor;
4617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4618 type Value = CreateDatabaseRequest;
4619
4620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4621 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
4622 }
4623
4624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
4625 where
4626 V: serde::de::MapAccess<'de>,
4627 {
4628 let mut db__ = None;
4629 while let Some(k) = map_.next_key()? {
4630 match k {
4631 GeneratedField::Db => {
4632 if db__.is_some() {
4633 return Err(serde::de::Error::duplicate_field("db"));
4634 }
4635 db__ = map_.next_value()?;
4636 }
4637 }
4638 }
4639 Ok(CreateDatabaseRequest {
4640 db: db__,
4641 })
4642 }
4643 }
4644 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
4645 }
4646}
4647impl serde::Serialize for CreateDatabaseResponse {
4648 #[allow(deprecated)]
4649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4650 where
4651 S: serde::Serializer,
4652 {
4653 use serde::ser::SerializeStruct;
4654 let mut len = 0;
4655 if self.status.is_some() {
4656 len += 1;
4657 }
4658 if self.version.is_some() {
4659 len += 1;
4660 }
4661 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
4662 if let Some(v) = self.status.as_ref() {
4663 struct_ser.serialize_field("status", v)?;
4664 }
4665 if let Some(v) = self.version.as_ref() {
4666 struct_ser.serialize_field("version", v)?;
4667 }
4668 struct_ser.end()
4669 }
4670}
4671impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
4672 #[allow(deprecated)]
4673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4674 where
4675 D: serde::Deserializer<'de>,
4676 {
4677 const FIELDS: &[&str] = &[
4678 "status",
4679 "version",
4680 ];
4681
4682 #[allow(clippy::enum_variant_names)]
4683 enum GeneratedField {
4684 Status,
4685 Version,
4686 }
4687 impl<'de> serde::Deserialize<'de> for GeneratedField {
4688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4689 where
4690 D: serde::Deserializer<'de>,
4691 {
4692 struct GeneratedVisitor;
4693
4694 impl serde::de::Visitor<'_> for GeneratedVisitor {
4695 type Value = GeneratedField;
4696
4697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4698 write!(formatter, "expected one of: {:?}", &FIELDS)
4699 }
4700
4701 #[allow(unused_variables)]
4702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4703 where
4704 E: serde::de::Error,
4705 {
4706 match value {
4707 "status" => Ok(GeneratedField::Status),
4708 "version" => Ok(GeneratedField::Version),
4709 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4710 }
4711 }
4712 }
4713 deserializer.deserialize_identifier(GeneratedVisitor)
4714 }
4715 }
4716 struct GeneratedVisitor;
4717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4718 type Value = CreateDatabaseResponse;
4719
4720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4721 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
4722 }
4723
4724 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
4725 where
4726 V: serde::de::MapAccess<'de>,
4727 {
4728 let mut status__ = None;
4729 let mut version__ = None;
4730 while let Some(k) = map_.next_key()? {
4731 match k {
4732 GeneratedField::Status => {
4733 if status__.is_some() {
4734 return Err(serde::de::Error::duplicate_field("status"));
4735 }
4736 status__ = map_.next_value()?;
4737 }
4738 GeneratedField::Version => {
4739 if version__.is_some() {
4740 return Err(serde::de::Error::duplicate_field("version"));
4741 }
4742 version__ = map_.next_value()?;
4743 }
4744 }
4745 }
4746 Ok(CreateDatabaseResponse {
4747 status: status__,
4748 version: version__,
4749 })
4750 }
4751 }
4752 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
4753 }
4754}
4755impl serde::Serialize for CreateFunctionRequest {
4756 #[allow(deprecated)]
4757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4758 where
4759 S: serde::Serializer,
4760 {
4761 use serde::ser::SerializeStruct;
4762 let mut len = 0;
4763 if self.function.is_some() {
4764 len += 1;
4765 }
4766 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
4767 if let Some(v) = self.function.as_ref() {
4768 struct_ser.serialize_field("function", v)?;
4769 }
4770 struct_ser.end()
4771 }
4772}
4773impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
4774 #[allow(deprecated)]
4775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4776 where
4777 D: serde::Deserializer<'de>,
4778 {
4779 const FIELDS: &[&str] = &[
4780 "function",
4781 ];
4782
4783 #[allow(clippy::enum_variant_names)]
4784 enum GeneratedField {
4785 Function,
4786 }
4787 impl<'de> serde::Deserialize<'de> for GeneratedField {
4788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4789 where
4790 D: serde::Deserializer<'de>,
4791 {
4792 struct GeneratedVisitor;
4793
4794 impl serde::de::Visitor<'_> for GeneratedVisitor {
4795 type Value = GeneratedField;
4796
4797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4798 write!(formatter, "expected one of: {:?}", &FIELDS)
4799 }
4800
4801 #[allow(unused_variables)]
4802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4803 where
4804 E: serde::de::Error,
4805 {
4806 match value {
4807 "function" => Ok(GeneratedField::Function),
4808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4809 }
4810 }
4811 }
4812 deserializer.deserialize_identifier(GeneratedVisitor)
4813 }
4814 }
4815 struct GeneratedVisitor;
4816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4817 type Value = CreateFunctionRequest;
4818
4819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4820 formatter.write_str("struct ddl_service.CreateFunctionRequest")
4821 }
4822
4823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
4824 where
4825 V: serde::de::MapAccess<'de>,
4826 {
4827 let mut function__ = None;
4828 while let Some(k) = map_.next_key()? {
4829 match k {
4830 GeneratedField::Function => {
4831 if function__.is_some() {
4832 return Err(serde::de::Error::duplicate_field("function"));
4833 }
4834 function__ = map_.next_value()?;
4835 }
4836 }
4837 }
4838 Ok(CreateFunctionRequest {
4839 function: function__,
4840 })
4841 }
4842 }
4843 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
4844 }
4845}
4846impl serde::Serialize for CreateFunctionResponse {
4847 #[allow(deprecated)]
4848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4849 where
4850 S: serde::Serializer,
4851 {
4852 use serde::ser::SerializeStruct;
4853 let mut len = 0;
4854 if self.status.is_some() {
4855 len += 1;
4856 }
4857 if self.version.is_some() {
4858 len += 1;
4859 }
4860 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
4861 if let Some(v) = self.status.as_ref() {
4862 struct_ser.serialize_field("status", v)?;
4863 }
4864 if let Some(v) = self.version.as_ref() {
4865 struct_ser.serialize_field("version", v)?;
4866 }
4867 struct_ser.end()
4868 }
4869}
4870impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
4871 #[allow(deprecated)]
4872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4873 where
4874 D: serde::Deserializer<'de>,
4875 {
4876 const FIELDS: &[&str] = &[
4877 "status",
4878 "version",
4879 ];
4880
4881 #[allow(clippy::enum_variant_names)]
4882 enum GeneratedField {
4883 Status,
4884 Version,
4885 }
4886 impl<'de> serde::Deserialize<'de> for GeneratedField {
4887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4888 where
4889 D: serde::Deserializer<'de>,
4890 {
4891 struct GeneratedVisitor;
4892
4893 impl serde::de::Visitor<'_> for GeneratedVisitor {
4894 type Value = GeneratedField;
4895
4896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4897 write!(formatter, "expected one of: {:?}", &FIELDS)
4898 }
4899
4900 #[allow(unused_variables)]
4901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4902 where
4903 E: serde::de::Error,
4904 {
4905 match value {
4906 "status" => Ok(GeneratedField::Status),
4907 "version" => Ok(GeneratedField::Version),
4908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4909 }
4910 }
4911 }
4912 deserializer.deserialize_identifier(GeneratedVisitor)
4913 }
4914 }
4915 struct GeneratedVisitor;
4916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4917 type Value = CreateFunctionResponse;
4918
4919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4920 formatter.write_str("struct ddl_service.CreateFunctionResponse")
4921 }
4922
4923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
4924 where
4925 V: serde::de::MapAccess<'de>,
4926 {
4927 let mut status__ = None;
4928 let mut version__ = None;
4929 while let Some(k) = map_.next_key()? {
4930 match k {
4931 GeneratedField::Status => {
4932 if status__.is_some() {
4933 return Err(serde::de::Error::duplicate_field("status"));
4934 }
4935 status__ = map_.next_value()?;
4936 }
4937 GeneratedField::Version => {
4938 if version__.is_some() {
4939 return Err(serde::de::Error::duplicate_field("version"));
4940 }
4941 version__ = map_.next_value()?;
4942 }
4943 }
4944 }
4945 Ok(CreateFunctionResponse {
4946 status: status__,
4947 version: version__,
4948 })
4949 }
4950 }
4951 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
4952 }
4953}
4954impl serde::Serialize for CreateIcebergTableRequest {
4955 #[allow(deprecated)]
4956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4957 where
4958 S: serde::Serializer,
4959 {
4960 use serde::ser::SerializeStruct;
4961 let mut len = 0;
4962 if self.table_info.is_some() {
4963 len += 1;
4964 }
4965 if self.sink_info.is_some() {
4966 len += 1;
4967 }
4968 if self.iceberg_source.is_some() {
4969 len += 1;
4970 }
4971 if self.if_not_exists {
4972 len += 1;
4973 }
4974 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
4975 if let Some(v) = self.table_info.as_ref() {
4976 struct_ser.serialize_field("tableInfo", v)?;
4977 }
4978 if let Some(v) = self.sink_info.as_ref() {
4979 struct_ser.serialize_field("sinkInfo", v)?;
4980 }
4981 if let Some(v) = self.iceberg_source.as_ref() {
4982 struct_ser.serialize_field("icebergSource", v)?;
4983 }
4984 if self.if_not_exists {
4985 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4986 }
4987 struct_ser.end()
4988 }
4989}
4990impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
4991 #[allow(deprecated)]
4992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4993 where
4994 D: serde::Deserializer<'de>,
4995 {
4996 const FIELDS: &[&str] = &[
4997 "table_info",
4998 "tableInfo",
4999 "sink_info",
5000 "sinkInfo",
5001 "iceberg_source",
5002 "icebergSource",
5003 "if_not_exists",
5004 "ifNotExists",
5005 ];
5006
5007 #[allow(clippy::enum_variant_names)]
5008 enum GeneratedField {
5009 TableInfo,
5010 SinkInfo,
5011 IcebergSource,
5012 IfNotExists,
5013 }
5014 impl<'de> serde::Deserialize<'de> for GeneratedField {
5015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5016 where
5017 D: serde::Deserializer<'de>,
5018 {
5019 struct GeneratedVisitor;
5020
5021 impl serde::de::Visitor<'_> for GeneratedVisitor {
5022 type Value = GeneratedField;
5023
5024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5025 write!(formatter, "expected one of: {:?}", &FIELDS)
5026 }
5027
5028 #[allow(unused_variables)]
5029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5030 where
5031 E: serde::de::Error,
5032 {
5033 match value {
5034 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
5035 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
5036 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
5037 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5039 }
5040 }
5041 }
5042 deserializer.deserialize_identifier(GeneratedVisitor)
5043 }
5044 }
5045 struct GeneratedVisitor;
5046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5047 type Value = CreateIcebergTableRequest;
5048
5049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5050 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
5051 }
5052
5053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
5054 where
5055 V: serde::de::MapAccess<'de>,
5056 {
5057 let mut table_info__ = None;
5058 let mut sink_info__ = None;
5059 let mut iceberg_source__ = None;
5060 let mut if_not_exists__ = None;
5061 while let Some(k) = map_.next_key()? {
5062 match k {
5063 GeneratedField::TableInfo => {
5064 if table_info__.is_some() {
5065 return Err(serde::de::Error::duplicate_field("tableInfo"));
5066 }
5067 table_info__ = map_.next_value()?;
5068 }
5069 GeneratedField::SinkInfo => {
5070 if sink_info__.is_some() {
5071 return Err(serde::de::Error::duplicate_field("sinkInfo"));
5072 }
5073 sink_info__ = map_.next_value()?;
5074 }
5075 GeneratedField::IcebergSource => {
5076 if iceberg_source__.is_some() {
5077 return Err(serde::de::Error::duplicate_field("icebergSource"));
5078 }
5079 iceberg_source__ = map_.next_value()?;
5080 }
5081 GeneratedField::IfNotExists => {
5082 if if_not_exists__.is_some() {
5083 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5084 }
5085 if_not_exists__ = Some(map_.next_value()?);
5086 }
5087 }
5088 }
5089 Ok(CreateIcebergTableRequest {
5090 table_info: table_info__,
5091 sink_info: sink_info__,
5092 iceberg_source: iceberg_source__,
5093 if_not_exists: if_not_exists__.unwrap_or_default(),
5094 })
5095 }
5096 }
5097 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
5098 }
5099}
5100impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
5101 #[allow(deprecated)]
5102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5103 where
5104 S: serde::Serializer,
5105 {
5106 use serde::ser::SerializeStruct;
5107 let mut len = 0;
5108 if self.sink.is_some() {
5109 len += 1;
5110 }
5111 if self.fragment_graph.is_some() {
5112 len += 1;
5113 }
5114 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
5115 if let Some(v) = self.sink.as_ref() {
5116 struct_ser.serialize_field("sink", v)?;
5117 }
5118 if let Some(v) = self.fragment_graph.as_ref() {
5119 struct_ser.serialize_field("fragmentGraph", v)?;
5120 }
5121 struct_ser.end()
5122 }
5123}
5124impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
5125 #[allow(deprecated)]
5126 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5127 where
5128 D: serde::Deserializer<'de>,
5129 {
5130 const FIELDS: &[&str] = &[
5131 "sink",
5132 "fragment_graph",
5133 "fragmentGraph",
5134 ];
5135
5136 #[allow(clippy::enum_variant_names)]
5137 enum GeneratedField {
5138 Sink,
5139 FragmentGraph,
5140 }
5141 impl<'de> serde::Deserialize<'de> for GeneratedField {
5142 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5143 where
5144 D: serde::Deserializer<'de>,
5145 {
5146 struct GeneratedVisitor;
5147
5148 impl serde::de::Visitor<'_> for GeneratedVisitor {
5149 type Value = GeneratedField;
5150
5151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5152 write!(formatter, "expected one of: {:?}", &FIELDS)
5153 }
5154
5155 #[allow(unused_variables)]
5156 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5157 where
5158 E: serde::de::Error,
5159 {
5160 match value {
5161 "sink" => Ok(GeneratedField::Sink),
5162 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5163 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5164 }
5165 }
5166 }
5167 deserializer.deserialize_identifier(GeneratedVisitor)
5168 }
5169 }
5170 struct GeneratedVisitor;
5171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5172 type Value = create_iceberg_table_request::SinkJobInfo;
5173
5174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5175 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
5176 }
5177
5178 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
5179 where
5180 V: serde::de::MapAccess<'de>,
5181 {
5182 let mut sink__ = None;
5183 let mut fragment_graph__ = None;
5184 while let Some(k) = map_.next_key()? {
5185 match k {
5186 GeneratedField::Sink => {
5187 if sink__.is_some() {
5188 return Err(serde::de::Error::duplicate_field("sink"));
5189 }
5190 sink__ = map_.next_value()?;
5191 }
5192 GeneratedField::FragmentGraph => {
5193 if fragment_graph__.is_some() {
5194 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5195 }
5196 fragment_graph__ = map_.next_value()?;
5197 }
5198 }
5199 }
5200 Ok(create_iceberg_table_request::SinkJobInfo {
5201 sink: sink__,
5202 fragment_graph: fragment_graph__,
5203 })
5204 }
5205 }
5206 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
5207 }
5208}
5209impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
5210 #[allow(deprecated)]
5211 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5212 where
5213 S: serde::Serializer,
5214 {
5215 use serde::ser::SerializeStruct;
5216 let mut len = 0;
5217 if self.source.is_some() {
5218 len += 1;
5219 }
5220 if self.table.is_some() {
5221 len += 1;
5222 }
5223 if self.fragment_graph.is_some() {
5224 len += 1;
5225 }
5226 if self.job_type != 0 {
5227 len += 1;
5228 }
5229 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
5230 if let Some(v) = self.source.as_ref() {
5231 struct_ser.serialize_field("source", v)?;
5232 }
5233 if let Some(v) = self.table.as_ref() {
5234 struct_ser.serialize_field("table", v)?;
5235 }
5236 if let Some(v) = self.fragment_graph.as_ref() {
5237 struct_ser.serialize_field("fragmentGraph", v)?;
5238 }
5239 if self.job_type != 0 {
5240 let v = TableJobType::try_from(self.job_type)
5241 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
5242 struct_ser.serialize_field("jobType", &v)?;
5243 }
5244 struct_ser.end()
5245 }
5246}
5247impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
5248 #[allow(deprecated)]
5249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5250 where
5251 D: serde::Deserializer<'de>,
5252 {
5253 const FIELDS: &[&str] = &[
5254 "source",
5255 "table",
5256 "fragment_graph",
5257 "fragmentGraph",
5258 "job_type",
5259 "jobType",
5260 ];
5261
5262 #[allow(clippy::enum_variant_names)]
5263 enum GeneratedField {
5264 Source,
5265 Table,
5266 FragmentGraph,
5267 JobType,
5268 }
5269 impl<'de> serde::Deserialize<'de> for GeneratedField {
5270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5271 where
5272 D: serde::Deserializer<'de>,
5273 {
5274 struct GeneratedVisitor;
5275
5276 impl serde::de::Visitor<'_> for GeneratedVisitor {
5277 type Value = GeneratedField;
5278
5279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5280 write!(formatter, "expected one of: {:?}", &FIELDS)
5281 }
5282
5283 #[allow(unused_variables)]
5284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5285 where
5286 E: serde::de::Error,
5287 {
5288 match value {
5289 "source" => Ok(GeneratedField::Source),
5290 "table" => Ok(GeneratedField::Table),
5291 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5292 "jobType" | "job_type" => Ok(GeneratedField::JobType),
5293 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5294 }
5295 }
5296 }
5297 deserializer.deserialize_identifier(GeneratedVisitor)
5298 }
5299 }
5300 struct GeneratedVisitor;
5301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5302 type Value = create_iceberg_table_request::TableJobInfo;
5303
5304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5305 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
5306 }
5307
5308 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
5309 where
5310 V: serde::de::MapAccess<'de>,
5311 {
5312 let mut source__ = None;
5313 let mut table__ = None;
5314 let mut fragment_graph__ = None;
5315 let mut job_type__ = None;
5316 while let Some(k) = map_.next_key()? {
5317 match k {
5318 GeneratedField::Source => {
5319 if source__.is_some() {
5320 return Err(serde::de::Error::duplicate_field("source"));
5321 }
5322 source__ = map_.next_value()?;
5323 }
5324 GeneratedField::Table => {
5325 if table__.is_some() {
5326 return Err(serde::de::Error::duplicate_field("table"));
5327 }
5328 table__ = map_.next_value()?;
5329 }
5330 GeneratedField::FragmentGraph => {
5331 if fragment_graph__.is_some() {
5332 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5333 }
5334 fragment_graph__ = map_.next_value()?;
5335 }
5336 GeneratedField::JobType => {
5337 if job_type__.is_some() {
5338 return Err(serde::de::Error::duplicate_field("jobType"));
5339 }
5340 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
5341 }
5342 }
5343 }
5344 Ok(create_iceberg_table_request::TableJobInfo {
5345 source: source__,
5346 table: table__,
5347 fragment_graph: fragment_graph__,
5348 job_type: job_type__.unwrap_or_default(),
5349 })
5350 }
5351 }
5352 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
5353 }
5354}
5355impl serde::Serialize for CreateIcebergTableResponse {
5356 #[allow(deprecated)]
5357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5358 where
5359 S: serde::Serializer,
5360 {
5361 use serde::ser::SerializeStruct;
5362 let mut len = 0;
5363 if self.status.is_some() {
5364 len += 1;
5365 }
5366 if self.version.is_some() {
5367 len += 1;
5368 }
5369 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
5370 if let Some(v) = self.status.as_ref() {
5371 struct_ser.serialize_field("status", v)?;
5372 }
5373 if let Some(v) = self.version.as_ref() {
5374 struct_ser.serialize_field("version", v)?;
5375 }
5376 struct_ser.end()
5377 }
5378}
5379impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
5380 #[allow(deprecated)]
5381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5382 where
5383 D: serde::Deserializer<'de>,
5384 {
5385 const FIELDS: &[&str] = &[
5386 "status",
5387 "version",
5388 ];
5389
5390 #[allow(clippy::enum_variant_names)]
5391 enum GeneratedField {
5392 Status,
5393 Version,
5394 }
5395 impl<'de> serde::Deserialize<'de> for GeneratedField {
5396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5397 where
5398 D: serde::Deserializer<'de>,
5399 {
5400 struct GeneratedVisitor;
5401
5402 impl serde::de::Visitor<'_> for GeneratedVisitor {
5403 type Value = GeneratedField;
5404
5405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5406 write!(formatter, "expected one of: {:?}", &FIELDS)
5407 }
5408
5409 #[allow(unused_variables)]
5410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5411 where
5412 E: serde::de::Error,
5413 {
5414 match value {
5415 "status" => Ok(GeneratedField::Status),
5416 "version" => Ok(GeneratedField::Version),
5417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5418 }
5419 }
5420 }
5421 deserializer.deserialize_identifier(GeneratedVisitor)
5422 }
5423 }
5424 struct GeneratedVisitor;
5425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5426 type Value = CreateIcebergTableResponse;
5427
5428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5429 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
5430 }
5431
5432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
5433 where
5434 V: serde::de::MapAccess<'de>,
5435 {
5436 let mut status__ = None;
5437 let mut version__ = None;
5438 while let Some(k) = map_.next_key()? {
5439 match k {
5440 GeneratedField::Status => {
5441 if status__.is_some() {
5442 return Err(serde::de::Error::duplicate_field("status"));
5443 }
5444 status__ = map_.next_value()?;
5445 }
5446 GeneratedField::Version => {
5447 if version__.is_some() {
5448 return Err(serde::de::Error::duplicate_field("version"));
5449 }
5450 version__ = map_.next_value()?;
5451 }
5452 }
5453 }
5454 Ok(CreateIcebergTableResponse {
5455 status: status__,
5456 version: version__,
5457 })
5458 }
5459 }
5460 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
5461 }
5462}
5463impl serde::Serialize for CreateIndexRequest {
5464 #[allow(deprecated)]
5465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5466 where
5467 S: serde::Serializer,
5468 {
5469 use serde::ser::SerializeStruct;
5470 let mut len = 0;
5471 if self.index.is_some() {
5472 len += 1;
5473 }
5474 if self.index_table.is_some() {
5475 len += 1;
5476 }
5477 if self.fragment_graph.is_some() {
5478 len += 1;
5479 }
5480 if self.if_not_exists {
5481 len += 1;
5482 }
5483 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
5484 if let Some(v) = self.index.as_ref() {
5485 struct_ser.serialize_field("index", v)?;
5486 }
5487 if let Some(v) = self.index_table.as_ref() {
5488 struct_ser.serialize_field("indexTable", v)?;
5489 }
5490 if let Some(v) = self.fragment_graph.as_ref() {
5491 struct_ser.serialize_field("fragmentGraph", v)?;
5492 }
5493 if self.if_not_exists {
5494 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5495 }
5496 struct_ser.end()
5497 }
5498}
5499impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
5500 #[allow(deprecated)]
5501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5502 where
5503 D: serde::Deserializer<'de>,
5504 {
5505 const FIELDS: &[&str] = &[
5506 "index",
5507 "index_table",
5508 "indexTable",
5509 "fragment_graph",
5510 "fragmentGraph",
5511 "if_not_exists",
5512 "ifNotExists",
5513 ];
5514
5515 #[allow(clippy::enum_variant_names)]
5516 enum GeneratedField {
5517 Index,
5518 IndexTable,
5519 FragmentGraph,
5520 IfNotExists,
5521 }
5522 impl<'de> serde::Deserialize<'de> for GeneratedField {
5523 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5524 where
5525 D: serde::Deserializer<'de>,
5526 {
5527 struct GeneratedVisitor;
5528
5529 impl serde::de::Visitor<'_> for GeneratedVisitor {
5530 type Value = GeneratedField;
5531
5532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5533 write!(formatter, "expected one of: {:?}", &FIELDS)
5534 }
5535
5536 #[allow(unused_variables)]
5537 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5538 where
5539 E: serde::de::Error,
5540 {
5541 match value {
5542 "index" => Ok(GeneratedField::Index),
5543 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
5544 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5545 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5546 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5547 }
5548 }
5549 }
5550 deserializer.deserialize_identifier(GeneratedVisitor)
5551 }
5552 }
5553 struct GeneratedVisitor;
5554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5555 type Value = CreateIndexRequest;
5556
5557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5558 formatter.write_str("struct ddl_service.CreateIndexRequest")
5559 }
5560
5561 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
5562 where
5563 V: serde::de::MapAccess<'de>,
5564 {
5565 let mut index__ = None;
5566 let mut index_table__ = None;
5567 let mut fragment_graph__ = None;
5568 let mut if_not_exists__ = None;
5569 while let Some(k) = map_.next_key()? {
5570 match k {
5571 GeneratedField::Index => {
5572 if index__.is_some() {
5573 return Err(serde::de::Error::duplicate_field("index"));
5574 }
5575 index__ = map_.next_value()?;
5576 }
5577 GeneratedField::IndexTable => {
5578 if index_table__.is_some() {
5579 return Err(serde::de::Error::duplicate_field("indexTable"));
5580 }
5581 index_table__ = map_.next_value()?;
5582 }
5583 GeneratedField::FragmentGraph => {
5584 if fragment_graph__.is_some() {
5585 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5586 }
5587 fragment_graph__ = map_.next_value()?;
5588 }
5589 GeneratedField::IfNotExists => {
5590 if if_not_exists__.is_some() {
5591 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5592 }
5593 if_not_exists__ = Some(map_.next_value()?);
5594 }
5595 }
5596 }
5597 Ok(CreateIndexRequest {
5598 index: index__,
5599 index_table: index_table__,
5600 fragment_graph: fragment_graph__,
5601 if_not_exists: if_not_exists__.unwrap_or_default(),
5602 })
5603 }
5604 }
5605 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
5606 }
5607}
5608impl serde::Serialize for CreateIndexResponse {
5609 #[allow(deprecated)]
5610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5611 where
5612 S: serde::Serializer,
5613 {
5614 use serde::ser::SerializeStruct;
5615 let mut len = 0;
5616 if self.status.is_some() {
5617 len += 1;
5618 }
5619 if self.version.is_some() {
5620 len += 1;
5621 }
5622 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
5623 if let Some(v) = self.status.as_ref() {
5624 struct_ser.serialize_field("status", v)?;
5625 }
5626 if let Some(v) = self.version.as_ref() {
5627 struct_ser.serialize_field("version", v)?;
5628 }
5629 struct_ser.end()
5630 }
5631}
5632impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
5633 #[allow(deprecated)]
5634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5635 where
5636 D: serde::Deserializer<'de>,
5637 {
5638 const FIELDS: &[&str] = &[
5639 "status",
5640 "version",
5641 ];
5642
5643 #[allow(clippy::enum_variant_names)]
5644 enum GeneratedField {
5645 Status,
5646 Version,
5647 }
5648 impl<'de> serde::Deserialize<'de> for GeneratedField {
5649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5650 where
5651 D: serde::Deserializer<'de>,
5652 {
5653 struct GeneratedVisitor;
5654
5655 impl serde::de::Visitor<'_> for GeneratedVisitor {
5656 type Value = GeneratedField;
5657
5658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5659 write!(formatter, "expected one of: {:?}", &FIELDS)
5660 }
5661
5662 #[allow(unused_variables)]
5663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5664 where
5665 E: serde::de::Error,
5666 {
5667 match value {
5668 "status" => Ok(GeneratedField::Status),
5669 "version" => Ok(GeneratedField::Version),
5670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5671 }
5672 }
5673 }
5674 deserializer.deserialize_identifier(GeneratedVisitor)
5675 }
5676 }
5677 struct GeneratedVisitor;
5678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5679 type Value = CreateIndexResponse;
5680
5681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5682 formatter.write_str("struct ddl_service.CreateIndexResponse")
5683 }
5684
5685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
5686 where
5687 V: serde::de::MapAccess<'de>,
5688 {
5689 let mut status__ = None;
5690 let mut version__ = None;
5691 while let Some(k) = map_.next_key()? {
5692 match k {
5693 GeneratedField::Status => {
5694 if status__.is_some() {
5695 return Err(serde::de::Error::duplicate_field("status"));
5696 }
5697 status__ = map_.next_value()?;
5698 }
5699 GeneratedField::Version => {
5700 if version__.is_some() {
5701 return Err(serde::de::Error::duplicate_field("version"));
5702 }
5703 version__ = map_.next_value()?;
5704 }
5705 }
5706 }
5707 Ok(CreateIndexResponse {
5708 status: status__,
5709 version: version__,
5710 })
5711 }
5712 }
5713 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
5714 }
5715}
5716impl serde::Serialize for CreateMaterializedViewRequest {
5717 #[allow(deprecated)]
5718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5719 where
5720 S: serde::Serializer,
5721 {
5722 use serde::ser::SerializeStruct;
5723 let mut len = 0;
5724 if self.materialized_view.is_some() {
5725 len += 1;
5726 }
5727 if self.fragment_graph.is_some() {
5728 len += 1;
5729 }
5730 if self.resource_type.is_some() {
5731 len += 1;
5732 }
5733 if !self.dependencies.is_empty() {
5734 len += 1;
5735 }
5736 if self.if_not_exists {
5737 len += 1;
5738 }
5739 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
5740 if let Some(v) = self.materialized_view.as_ref() {
5741 struct_ser.serialize_field("materializedView", v)?;
5742 }
5743 if let Some(v) = self.fragment_graph.as_ref() {
5744 struct_ser.serialize_field("fragmentGraph", v)?;
5745 }
5746 if let Some(v) = self.resource_type.as_ref() {
5747 struct_ser.serialize_field("resourceType", v)?;
5748 }
5749 if !self.dependencies.is_empty() {
5750 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5751 }
5752 if self.if_not_exists {
5753 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5754 }
5755 struct_ser.end()
5756 }
5757}
5758impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
5759 #[allow(deprecated)]
5760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5761 where
5762 D: serde::Deserializer<'de>,
5763 {
5764 const FIELDS: &[&str] = &[
5765 "materialized_view",
5766 "materializedView",
5767 "fragment_graph",
5768 "fragmentGraph",
5769 "resource_type",
5770 "resourceType",
5771 "dependencies",
5772 "if_not_exists",
5773 "ifNotExists",
5774 ];
5775
5776 #[allow(clippy::enum_variant_names)]
5777 enum GeneratedField {
5778 MaterializedView,
5779 FragmentGraph,
5780 ResourceType,
5781 Dependencies,
5782 IfNotExists,
5783 }
5784 impl<'de> serde::Deserialize<'de> for GeneratedField {
5785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5786 where
5787 D: serde::Deserializer<'de>,
5788 {
5789 struct GeneratedVisitor;
5790
5791 impl serde::de::Visitor<'_> for GeneratedVisitor {
5792 type Value = GeneratedField;
5793
5794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5795 write!(formatter, "expected one of: {:?}", &FIELDS)
5796 }
5797
5798 #[allow(unused_variables)]
5799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5800 where
5801 E: serde::de::Error,
5802 {
5803 match value {
5804 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5805 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5806 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
5807 "dependencies" => Ok(GeneratedField::Dependencies),
5808 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5810 }
5811 }
5812 }
5813 deserializer.deserialize_identifier(GeneratedVisitor)
5814 }
5815 }
5816 struct GeneratedVisitor;
5817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5818 type Value = CreateMaterializedViewRequest;
5819
5820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5821 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
5822 }
5823
5824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
5825 where
5826 V: serde::de::MapAccess<'de>,
5827 {
5828 let mut materialized_view__ = None;
5829 let mut fragment_graph__ = None;
5830 let mut resource_type__ = None;
5831 let mut dependencies__ = None;
5832 let mut if_not_exists__ = None;
5833 while let Some(k) = map_.next_key()? {
5834 match k {
5835 GeneratedField::MaterializedView => {
5836 if materialized_view__.is_some() {
5837 return Err(serde::de::Error::duplicate_field("materializedView"));
5838 }
5839 materialized_view__ = map_.next_value()?;
5840 }
5841 GeneratedField::FragmentGraph => {
5842 if fragment_graph__.is_some() {
5843 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5844 }
5845 fragment_graph__ = map_.next_value()?;
5846 }
5847 GeneratedField::ResourceType => {
5848 if resource_type__.is_some() {
5849 return Err(serde::de::Error::duplicate_field("resourceType"));
5850 }
5851 resource_type__ = map_.next_value()?;
5852 }
5853 GeneratedField::Dependencies => {
5854 if dependencies__.is_some() {
5855 return Err(serde::de::Error::duplicate_field("dependencies"));
5856 }
5857 dependencies__ =
5858 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5859 .into_iter().map(|x| x.0).collect())
5860 ;
5861 }
5862 GeneratedField::IfNotExists => {
5863 if if_not_exists__.is_some() {
5864 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5865 }
5866 if_not_exists__ = Some(map_.next_value()?);
5867 }
5868 }
5869 }
5870 Ok(CreateMaterializedViewRequest {
5871 materialized_view: materialized_view__,
5872 fragment_graph: fragment_graph__,
5873 resource_type: resource_type__,
5874 dependencies: dependencies__.unwrap_or_default(),
5875 if_not_exists: if_not_exists__.unwrap_or_default(),
5876 })
5877 }
5878 }
5879 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
5880 }
5881}
5882impl serde::Serialize for CreateMaterializedViewResponse {
5883 #[allow(deprecated)]
5884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5885 where
5886 S: serde::Serializer,
5887 {
5888 use serde::ser::SerializeStruct;
5889 let mut len = 0;
5890 if self.status.is_some() {
5891 len += 1;
5892 }
5893 if self.version.is_some() {
5894 len += 1;
5895 }
5896 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
5897 if let Some(v) = self.status.as_ref() {
5898 struct_ser.serialize_field("status", v)?;
5899 }
5900 if let Some(v) = self.version.as_ref() {
5901 struct_ser.serialize_field("version", v)?;
5902 }
5903 struct_ser.end()
5904 }
5905}
5906impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
5907 #[allow(deprecated)]
5908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5909 where
5910 D: serde::Deserializer<'de>,
5911 {
5912 const FIELDS: &[&str] = &[
5913 "status",
5914 "version",
5915 ];
5916
5917 #[allow(clippy::enum_variant_names)]
5918 enum GeneratedField {
5919 Status,
5920 Version,
5921 }
5922 impl<'de> serde::Deserialize<'de> for GeneratedField {
5923 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5924 where
5925 D: serde::Deserializer<'de>,
5926 {
5927 struct GeneratedVisitor;
5928
5929 impl serde::de::Visitor<'_> for GeneratedVisitor {
5930 type Value = GeneratedField;
5931
5932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5933 write!(formatter, "expected one of: {:?}", &FIELDS)
5934 }
5935
5936 #[allow(unused_variables)]
5937 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5938 where
5939 E: serde::de::Error,
5940 {
5941 match value {
5942 "status" => Ok(GeneratedField::Status),
5943 "version" => Ok(GeneratedField::Version),
5944 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5945 }
5946 }
5947 }
5948 deserializer.deserialize_identifier(GeneratedVisitor)
5949 }
5950 }
5951 struct GeneratedVisitor;
5952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5953 type Value = CreateMaterializedViewResponse;
5954
5955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5956 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
5957 }
5958
5959 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
5960 where
5961 V: serde::de::MapAccess<'de>,
5962 {
5963 let mut status__ = None;
5964 let mut version__ = None;
5965 while let Some(k) = map_.next_key()? {
5966 match k {
5967 GeneratedField::Status => {
5968 if status__.is_some() {
5969 return Err(serde::de::Error::duplicate_field("status"));
5970 }
5971 status__ = map_.next_value()?;
5972 }
5973 GeneratedField::Version => {
5974 if version__.is_some() {
5975 return Err(serde::de::Error::duplicate_field("version"));
5976 }
5977 version__ = map_.next_value()?;
5978 }
5979 }
5980 }
5981 Ok(CreateMaterializedViewResponse {
5982 status: status__,
5983 version: version__,
5984 })
5985 }
5986 }
5987 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
5988 }
5989}
5990impl serde::Serialize for CreateSchemaRequest {
5991 #[allow(deprecated)]
5992 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5993 where
5994 S: serde::Serializer,
5995 {
5996 use serde::ser::SerializeStruct;
5997 let mut len = 0;
5998 if self.schema.is_some() {
5999 len += 1;
6000 }
6001 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
6002 if let Some(v) = self.schema.as_ref() {
6003 struct_ser.serialize_field("schema", v)?;
6004 }
6005 struct_ser.end()
6006 }
6007}
6008impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
6009 #[allow(deprecated)]
6010 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6011 where
6012 D: serde::Deserializer<'de>,
6013 {
6014 const FIELDS: &[&str] = &[
6015 "schema",
6016 ];
6017
6018 #[allow(clippy::enum_variant_names)]
6019 enum GeneratedField {
6020 Schema,
6021 }
6022 impl<'de> serde::Deserialize<'de> for GeneratedField {
6023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6024 where
6025 D: serde::Deserializer<'de>,
6026 {
6027 struct GeneratedVisitor;
6028
6029 impl serde::de::Visitor<'_> for GeneratedVisitor {
6030 type Value = GeneratedField;
6031
6032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6033 write!(formatter, "expected one of: {:?}", &FIELDS)
6034 }
6035
6036 #[allow(unused_variables)]
6037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6038 where
6039 E: serde::de::Error,
6040 {
6041 match value {
6042 "schema" => Ok(GeneratedField::Schema),
6043 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6044 }
6045 }
6046 }
6047 deserializer.deserialize_identifier(GeneratedVisitor)
6048 }
6049 }
6050 struct GeneratedVisitor;
6051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6052 type Value = CreateSchemaRequest;
6053
6054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6055 formatter.write_str("struct ddl_service.CreateSchemaRequest")
6056 }
6057
6058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
6059 where
6060 V: serde::de::MapAccess<'de>,
6061 {
6062 let mut schema__ = None;
6063 while let Some(k) = map_.next_key()? {
6064 match k {
6065 GeneratedField::Schema => {
6066 if schema__.is_some() {
6067 return Err(serde::de::Error::duplicate_field("schema"));
6068 }
6069 schema__ = map_.next_value()?;
6070 }
6071 }
6072 }
6073 Ok(CreateSchemaRequest {
6074 schema: schema__,
6075 })
6076 }
6077 }
6078 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
6079 }
6080}
6081impl serde::Serialize for CreateSchemaResponse {
6082 #[allow(deprecated)]
6083 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6084 where
6085 S: serde::Serializer,
6086 {
6087 use serde::ser::SerializeStruct;
6088 let mut len = 0;
6089 if self.status.is_some() {
6090 len += 1;
6091 }
6092 if self.version.is_some() {
6093 len += 1;
6094 }
6095 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
6096 if let Some(v) = self.status.as_ref() {
6097 struct_ser.serialize_field("status", v)?;
6098 }
6099 if let Some(v) = self.version.as_ref() {
6100 struct_ser.serialize_field("version", v)?;
6101 }
6102 struct_ser.end()
6103 }
6104}
6105impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
6106 #[allow(deprecated)]
6107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6108 where
6109 D: serde::Deserializer<'de>,
6110 {
6111 const FIELDS: &[&str] = &[
6112 "status",
6113 "version",
6114 ];
6115
6116 #[allow(clippy::enum_variant_names)]
6117 enum GeneratedField {
6118 Status,
6119 Version,
6120 }
6121 impl<'de> serde::Deserialize<'de> for GeneratedField {
6122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6123 where
6124 D: serde::Deserializer<'de>,
6125 {
6126 struct GeneratedVisitor;
6127
6128 impl serde::de::Visitor<'_> for GeneratedVisitor {
6129 type Value = GeneratedField;
6130
6131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6132 write!(formatter, "expected one of: {:?}", &FIELDS)
6133 }
6134
6135 #[allow(unused_variables)]
6136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6137 where
6138 E: serde::de::Error,
6139 {
6140 match value {
6141 "status" => Ok(GeneratedField::Status),
6142 "version" => Ok(GeneratedField::Version),
6143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6144 }
6145 }
6146 }
6147 deserializer.deserialize_identifier(GeneratedVisitor)
6148 }
6149 }
6150 struct GeneratedVisitor;
6151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6152 type Value = CreateSchemaResponse;
6153
6154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6155 formatter.write_str("struct ddl_service.CreateSchemaResponse")
6156 }
6157
6158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
6159 where
6160 V: serde::de::MapAccess<'de>,
6161 {
6162 let mut status__ = None;
6163 let mut version__ = None;
6164 while let Some(k) = map_.next_key()? {
6165 match k {
6166 GeneratedField::Status => {
6167 if status__.is_some() {
6168 return Err(serde::de::Error::duplicate_field("status"));
6169 }
6170 status__ = map_.next_value()?;
6171 }
6172 GeneratedField::Version => {
6173 if version__.is_some() {
6174 return Err(serde::de::Error::duplicate_field("version"));
6175 }
6176 version__ = map_.next_value()?;
6177 }
6178 }
6179 }
6180 Ok(CreateSchemaResponse {
6181 status: status__,
6182 version: version__,
6183 })
6184 }
6185 }
6186 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
6187 }
6188}
6189impl serde::Serialize for CreateSecretRequest {
6190 #[allow(deprecated)]
6191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6192 where
6193 S: serde::Serializer,
6194 {
6195 use serde::ser::SerializeStruct;
6196 let mut len = 0;
6197 if !self.name.is_empty() {
6198 len += 1;
6199 }
6200 if !self.value.is_empty() {
6201 len += 1;
6202 }
6203 if self.database_id != 0 {
6204 len += 1;
6205 }
6206 if self.schema_id != 0 {
6207 len += 1;
6208 }
6209 if self.owner_id != 0 {
6210 len += 1;
6211 }
6212 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
6213 if !self.name.is_empty() {
6214 struct_ser.serialize_field("name", &self.name)?;
6215 }
6216 if !self.value.is_empty() {
6217 #[allow(clippy::needless_borrow)]
6218 #[allow(clippy::needless_borrows_for_generic_args)]
6219 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
6220 }
6221 if self.database_id != 0 {
6222 struct_ser.serialize_field("databaseId", &self.database_id)?;
6223 }
6224 if self.schema_id != 0 {
6225 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6226 }
6227 if self.owner_id != 0 {
6228 struct_ser.serialize_field("ownerId", &self.owner_id)?;
6229 }
6230 struct_ser.end()
6231 }
6232}
6233impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
6234 #[allow(deprecated)]
6235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6236 where
6237 D: serde::Deserializer<'de>,
6238 {
6239 const FIELDS: &[&str] = &[
6240 "name",
6241 "value",
6242 "database_id",
6243 "databaseId",
6244 "schema_id",
6245 "schemaId",
6246 "owner_id",
6247 "ownerId",
6248 ];
6249
6250 #[allow(clippy::enum_variant_names)]
6251 enum GeneratedField {
6252 Name,
6253 Value,
6254 DatabaseId,
6255 SchemaId,
6256 OwnerId,
6257 }
6258 impl<'de> serde::Deserialize<'de> for GeneratedField {
6259 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6260 where
6261 D: serde::Deserializer<'de>,
6262 {
6263 struct GeneratedVisitor;
6264
6265 impl serde::de::Visitor<'_> for GeneratedVisitor {
6266 type Value = GeneratedField;
6267
6268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6269 write!(formatter, "expected one of: {:?}", &FIELDS)
6270 }
6271
6272 #[allow(unused_variables)]
6273 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6274 where
6275 E: serde::de::Error,
6276 {
6277 match value {
6278 "name" => Ok(GeneratedField::Name),
6279 "value" => Ok(GeneratedField::Value),
6280 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6281 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6282 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
6283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6284 }
6285 }
6286 }
6287 deserializer.deserialize_identifier(GeneratedVisitor)
6288 }
6289 }
6290 struct GeneratedVisitor;
6291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6292 type Value = CreateSecretRequest;
6293
6294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6295 formatter.write_str("struct ddl_service.CreateSecretRequest")
6296 }
6297
6298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
6299 where
6300 V: serde::de::MapAccess<'de>,
6301 {
6302 let mut name__ = None;
6303 let mut value__ = None;
6304 let mut database_id__ = None;
6305 let mut schema_id__ = None;
6306 let mut owner_id__ = None;
6307 while let Some(k) = map_.next_key()? {
6308 match k {
6309 GeneratedField::Name => {
6310 if name__.is_some() {
6311 return Err(serde::de::Error::duplicate_field("name"));
6312 }
6313 name__ = Some(map_.next_value()?);
6314 }
6315 GeneratedField::Value => {
6316 if value__.is_some() {
6317 return Err(serde::de::Error::duplicate_field("value"));
6318 }
6319 value__ =
6320 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
6321 ;
6322 }
6323 GeneratedField::DatabaseId => {
6324 if database_id__.is_some() {
6325 return Err(serde::de::Error::duplicate_field("databaseId"));
6326 }
6327 database_id__ =
6328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6329 ;
6330 }
6331 GeneratedField::SchemaId => {
6332 if schema_id__.is_some() {
6333 return Err(serde::de::Error::duplicate_field("schemaId"));
6334 }
6335 schema_id__ =
6336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6337 ;
6338 }
6339 GeneratedField::OwnerId => {
6340 if owner_id__.is_some() {
6341 return Err(serde::de::Error::duplicate_field("ownerId"));
6342 }
6343 owner_id__ =
6344 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6345 ;
6346 }
6347 }
6348 }
6349 Ok(CreateSecretRequest {
6350 name: name__.unwrap_or_default(),
6351 value: value__.unwrap_or_default(),
6352 database_id: database_id__.unwrap_or_default(),
6353 schema_id: schema_id__.unwrap_or_default(),
6354 owner_id: owner_id__.unwrap_or_default(),
6355 })
6356 }
6357 }
6358 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
6359 }
6360}
6361impl serde::Serialize for CreateSecretResponse {
6362 #[allow(deprecated)]
6363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6364 where
6365 S: serde::Serializer,
6366 {
6367 use serde::ser::SerializeStruct;
6368 let mut len = 0;
6369 if self.version.is_some() {
6370 len += 1;
6371 }
6372 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
6373 if let Some(v) = self.version.as_ref() {
6374 struct_ser.serialize_field("version", v)?;
6375 }
6376 struct_ser.end()
6377 }
6378}
6379impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
6380 #[allow(deprecated)]
6381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6382 where
6383 D: serde::Deserializer<'de>,
6384 {
6385 const FIELDS: &[&str] = &[
6386 "version",
6387 ];
6388
6389 #[allow(clippy::enum_variant_names)]
6390 enum GeneratedField {
6391 Version,
6392 }
6393 impl<'de> serde::Deserialize<'de> for GeneratedField {
6394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6395 where
6396 D: serde::Deserializer<'de>,
6397 {
6398 struct GeneratedVisitor;
6399
6400 impl serde::de::Visitor<'_> for GeneratedVisitor {
6401 type Value = GeneratedField;
6402
6403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6404 write!(formatter, "expected one of: {:?}", &FIELDS)
6405 }
6406
6407 #[allow(unused_variables)]
6408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6409 where
6410 E: serde::de::Error,
6411 {
6412 match value {
6413 "version" => Ok(GeneratedField::Version),
6414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6415 }
6416 }
6417 }
6418 deserializer.deserialize_identifier(GeneratedVisitor)
6419 }
6420 }
6421 struct GeneratedVisitor;
6422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6423 type Value = CreateSecretResponse;
6424
6425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6426 formatter.write_str("struct ddl_service.CreateSecretResponse")
6427 }
6428
6429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
6430 where
6431 V: serde::de::MapAccess<'de>,
6432 {
6433 let mut version__ = None;
6434 while let Some(k) = map_.next_key()? {
6435 match k {
6436 GeneratedField::Version => {
6437 if version__.is_some() {
6438 return Err(serde::de::Error::duplicate_field("version"));
6439 }
6440 version__ = map_.next_value()?;
6441 }
6442 }
6443 }
6444 Ok(CreateSecretResponse {
6445 version: version__,
6446 })
6447 }
6448 }
6449 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
6450 }
6451}
6452impl serde::Serialize for CreateSinkRequest {
6453 #[allow(deprecated)]
6454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6455 where
6456 S: serde::Serializer,
6457 {
6458 use serde::ser::SerializeStruct;
6459 let mut len = 0;
6460 if self.sink.is_some() {
6461 len += 1;
6462 }
6463 if self.fragment_graph.is_some() {
6464 len += 1;
6465 }
6466 if !self.dependencies.is_empty() {
6467 len += 1;
6468 }
6469 if self.if_not_exists {
6470 len += 1;
6471 }
6472 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
6473 if let Some(v) = self.sink.as_ref() {
6474 struct_ser.serialize_field("sink", v)?;
6475 }
6476 if let Some(v) = self.fragment_graph.as_ref() {
6477 struct_ser.serialize_field("fragmentGraph", v)?;
6478 }
6479 if !self.dependencies.is_empty() {
6480 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6481 }
6482 if self.if_not_exists {
6483 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6484 }
6485 struct_ser.end()
6486 }
6487}
6488impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6489 #[allow(deprecated)]
6490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6491 where
6492 D: serde::Deserializer<'de>,
6493 {
6494 const FIELDS: &[&str] = &[
6495 "sink",
6496 "fragment_graph",
6497 "fragmentGraph",
6498 "dependencies",
6499 "if_not_exists",
6500 "ifNotExists",
6501 ];
6502
6503 #[allow(clippy::enum_variant_names)]
6504 enum GeneratedField {
6505 Sink,
6506 FragmentGraph,
6507 Dependencies,
6508 IfNotExists,
6509 }
6510 impl<'de> serde::Deserialize<'de> for GeneratedField {
6511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6512 where
6513 D: serde::Deserializer<'de>,
6514 {
6515 struct GeneratedVisitor;
6516
6517 impl serde::de::Visitor<'_> for GeneratedVisitor {
6518 type Value = GeneratedField;
6519
6520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6521 write!(formatter, "expected one of: {:?}", &FIELDS)
6522 }
6523
6524 #[allow(unused_variables)]
6525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6526 where
6527 E: serde::de::Error,
6528 {
6529 match value {
6530 "sink" => Ok(GeneratedField::Sink),
6531 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6532 "dependencies" => Ok(GeneratedField::Dependencies),
6533 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6535 }
6536 }
6537 }
6538 deserializer.deserialize_identifier(GeneratedVisitor)
6539 }
6540 }
6541 struct GeneratedVisitor;
6542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6543 type Value = CreateSinkRequest;
6544
6545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6546 formatter.write_str("struct ddl_service.CreateSinkRequest")
6547 }
6548
6549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6550 where
6551 V: serde::de::MapAccess<'de>,
6552 {
6553 let mut sink__ = None;
6554 let mut fragment_graph__ = None;
6555 let mut dependencies__ = None;
6556 let mut if_not_exists__ = None;
6557 while let Some(k) = map_.next_key()? {
6558 match k {
6559 GeneratedField::Sink => {
6560 if sink__.is_some() {
6561 return Err(serde::de::Error::duplicate_field("sink"));
6562 }
6563 sink__ = map_.next_value()?;
6564 }
6565 GeneratedField::FragmentGraph => {
6566 if fragment_graph__.is_some() {
6567 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6568 }
6569 fragment_graph__ = map_.next_value()?;
6570 }
6571 GeneratedField::Dependencies => {
6572 if dependencies__.is_some() {
6573 return Err(serde::de::Error::duplicate_field("dependencies"));
6574 }
6575 dependencies__ =
6576 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6577 .into_iter().map(|x| x.0).collect())
6578 ;
6579 }
6580 GeneratedField::IfNotExists => {
6581 if if_not_exists__.is_some() {
6582 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6583 }
6584 if_not_exists__ = Some(map_.next_value()?);
6585 }
6586 }
6587 }
6588 Ok(CreateSinkRequest {
6589 sink: sink__,
6590 fragment_graph: fragment_graph__,
6591 dependencies: dependencies__.unwrap_or_default(),
6592 if_not_exists: if_not_exists__.unwrap_or_default(),
6593 })
6594 }
6595 }
6596 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6597 }
6598}
6599impl serde::Serialize for CreateSinkResponse {
6600 #[allow(deprecated)]
6601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6602 where
6603 S: serde::Serializer,
6604 {
6605 use serde::ser::SerializeStruct;
6606 let mut len = 0;
6607 if self.status.is_some() {
6608 len += 1;
6609 }
6610 if self.version.is_some() {
6611 len += 1;
6612 }
6613 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6614 if let Some(v) = self.status.as_ref() {
6615 struct_ser.serialize_field("status", v)?;
6616 }
6617 if let Some(v) = self.version.as_ref() {
6618 struct_ser.serialize_field("version", v)?;
6619 }
6620 struct_ser.end()
6621 }
6622}
6623impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6624 #[allow(deprecated)]
6625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6626 where
6627 D: serde::Deserializer<'de>,
6628 {
6629 const FIELDS: &[&str] = &[
6630 "status",
6631 "version",
6632 ];
6633
6634 #[allow(clippy::enum_variant_names)]
6635 enum GeneratedField {
6636 Status,
6637 Version,
6638 }
6639 impl<'de> serde::Deserialize<'de> for GeneratedField {
6640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6641 where
6642 D: serde::Deserializer<'de>,
6643 {
6644 struct GeneratedVisitor;
6645
6646 impl serde::de::Visitor<'_> for GeneratedVisitor {
6647 type Value = GeneratedField;
6648
6649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6650 write!(formatter, "expected one of: {:?}", &FIELDS)
6651 }
6652
6653 #[allow(unused_variables)]
6654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6655 where
6656 E: serde::de::Error,
6657 {
6658 match value {
6659 "status" => Ok(GeneratedField::Status),
6660 "version" => Ok(GeneratedField::Version),
6661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6662 }
6663 }
6664 }
6665 deserializer.deserialize_identifier(GeneratedVisitor)
6666 }
6667 }
6668 struct GeneratedVisitor;
6669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6670 type Value = CreateSinkResponse;
6671
6672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6673 formatter.write_str("struct ddl_service.CreateSinkResponse")
6674 }
6675
6676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6677 where
6678 V: serde::de::MapAccess<'de>,
6679 {
6680 let mut status__ = None;
6681 let mut version__ = None;
6682 while let Some(k) = map_.next_key()? {
6683 match k {
6684 GeneratedField::Status => {
6685 if status__.is_some() {
6686 return Err(serde::de::Error::duplicate_field("status"));
6687 }
6688 status__ = map_.next_value()?;
6689 }
6690 GeneratedField::Version => {
6691 if version__.is_some() {
6692 return Err(serde::de::Error::duplicate_field("version"));
6693 }
6694 version__ = map_.next_value()?;
6695 }
6696 }
6697 }
6698 Ok(CreateSinkResponse {
6699 status: status__,
6700 version: version__,
6701 })
6702 }
6703 }
6704 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
6705 }
6706}
6707impl serde::Serialize for CreateSourceRequest {
6708 #[allow(deprecated)]
6709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6710 where
6711 S: serde::Serializer,
6712 {
6713 use serde::ser::SerializeStruct;
6714 let mut len = 0;
6715 if self.source.is_some() {
6716 len += 1;
6717 }
6718 if self.fragment_graph.is_some() {
6719 len += 1;
6720 }
6721 if self.if_not_exists {
6722 len += 1;
6723 }
6724 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
6725 if let Some(v) = self.source.as_ref() {
6726 struct_ser.serialize_field("source", v)?;
6727 }
6728 if let Some(v) = self.fragment_graph.as_ref() {
6729 struct_ser.serialize_field("fragmentGraph", v)?;
6730 }
6731 if self.if_not_exists {
6732 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6733 }
6734 struct_ser.end()
6735 }
6736}
6737impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
6738 #[allow(deprecated)]
6739 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6740 where
6741 D: serde::Deserializer<'de>,
6742 {
6743 const FIELDS: &[&str] = &[
6744 "source",
6745 "fragment_graph",
6746 "fragmentGraph",
6747 "if_not_exists",
6748 "ifNotExists",
6749 ];
6750
6751 #[allow(clippy::enum_variant_names)]
6752 enum GeneratedField {
6753 Source,
6754 FragmentGraph,
6755 IfNotExists,
6756 }
6757 impl<'de> serde::Deserialize<'de> for GeneratedField {
6758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6759 where
6760 D: serde::Deserializer<'de>,
6761 {
6762 struct GeneratedVisitor;
6763
6764 impl serde::de::Visitor<'_> for GeneratedVisitor {
6765 type Value = GeneratedField;
6766
6767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6768 write!(formatter, "expected one of: {:?}", &FIELDS)
6769 }
6770
6771 #[allow(unused_variables)]
6772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6773 where
6774 E: serde::de::Error,
6775 {
6776 match value {
6777 "source" => Ok(GeneratedField::Source),
6778 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6779 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6780 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6781 }
6782 }
6783 }
6784 deserializer.deserialize_identifier(GeneratedVisitor)
6785 }
6786 }
6787 struct GeneratedVisitor;
6788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6789 type Value = CreateSourceRequest;
6790
6791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6792 formatter.write_str("struct ddl_service.CreateSourceRequest")
6793 }
6794
6795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
6796 where
6797 V: serde::de::MapAccess<'de>,
6798 {
6799 let mut source__ = None;
6800 let mut fragment_graph__ = None;
6801 let mut if_not_exists__ = None;
6802 while let Some(k) = map_.next_key()? {
6803 match k {
6804 GeneratedField::Source => {
6805 if source__.is_some() {
6806 return Err(serde::de::Error::duplicate_field("source"));
6807 }
6808 source__ = map_.next_value()?;
6809 }
6810 GeneratedField::FragmentGraph => {
6811 if fragment_graph__.is_some() {
6812 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6813 }
6814 fragment_graph__ = map_.next_value()?;
6815 }
6816 GeneratedField::IfNotExists => {
6817 if if_not_exists__.is_some() {
6818 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6819 }
6820 if_not_exists__ = Some(map_.next_value()?);
6821 }
6822 }
6823 }
6824 Ok(CreateSourceRequest {
6825 source: source__,
6826 fragment_graph: fragment_graph__,
6827 if_not_exists: if_not_exists__.unwrap_or_default(),
6828 })
6829 }
6830 }
6831 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
6832 }
6833}
6834impl serde::Serialize for CreateSourceResponse {
6835 #[allow(deprecated)]
6836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6837 where
6838 S: serde::Serializer,
6839 {
6840 use serde::ser::SerializeStruct;
6841 let mut len = 0;
6842 if self.status.is_some() {
6843 len += 1;
6844 }
6845 if self.version.is_some() {
6846 len += 1;
6847 }
6848 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
6849 if let Some(v) = self.status.as_ref() {
6850 struct_ser.serialize_field("status", v)?;
6851 }
6852 if let Some(v) = self.version.as_ref() {
6853 struct_ser.serialize_field("version", v)?;
6854 }
6855 struct_ser.end()
6856 }
6857}
6858impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
6859 #[allow(deprecated)]
6860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6861 where
6862 D: serde::Deserializer<'de>,
6863 {
6864 const FIELDS: &[&str] = &[
6865 "status",
6866 "version",
6867 ];
6868
6869 #[allow(clippy::enum_variant_names)]
6870 enum GeneratedField {
6871 Status,
6872 Version,
6873 }
6874 impl<'de> serde::Deserialize<'de> for GeneratedField {
6875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6876 where
6877 D: serde::Deserializer<'de>,
6878 {
6879 struct GeneratedVisitor;
6880
6881 impl serde::de::Visitor<'_> for GeneratedVisitor {
6882 type Value = GeneratedField;
6883
6884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6885 write!(formatter, "expected one of: {:?}", &FIELDS)
6886 }
6887
6888 #[allow(unused_variables)]
6889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6890 where
6891 E: serde::de::Error,
6892 {
6893 match value {
6894 "status" => Ok(GeneratedField::Status),
6895 "version" => Ok(GeneratedField::Version),
6896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6897 }
6898 }
6899 }
6900 deserializer.deserialize_identifier(GeneratedVisitor)
6901 }
6902 }
6903 struct GeneratedVisitor;
6904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6905 type Value = CreateSourceResponse;
6906
6907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6908 formatter.write_str("struct ddl_service.CreateSourceResponse")
6909 }
6910
6911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
6912 where
6913 V: serde::de::MapAccess<'de>,
6914 {
6915 let mut status__ = None;
6916 let mut version__ = None;
6917 while let Some(k) = map_.next_key()? {
6918 match k {
6919 GeneratedField::Status => {
6920 if status__.is_some() {
6921 return Err(serde::de::Error::duplicate_field("status"));
6922 }
6923 status__ = map_.next_value()?;
6924 }
6925 GeneratedField::Version => {
6926 if version__.is_some() {
6927 return Err(serde::de::Error::duplicate_field("version"));
6928 }
6929 version__ = map_.next_value()?;
6930 }
6931 }
6932 }
6933 Ok(CreateSourceResponse {
6934 status: status__,
6935 version: version__,
6936 })
6937 }
6938 }
6939 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
6940 }
6941}
6942impl serde::Serialize for CreateSubscriptionRequest {
6943 #[allow(deprecated)]
6944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6945 where
6946 S: serde::Serializer,
6947 {
6948 use serde::ser::SerializeStruct;
6949 let mut len = 0;
6950 if self.subscription.is_some() {
6951 len += 1;
6952 }
6953 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
6954 if let Some(v) = self.subscription.as_ref() {
6955 struct_ser.serialize_field("subscription", v)?;
6956 }
6957 struct_ser.end()
6958 }
6959}
6960impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
6961 #[allow(deprecated)]
6962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6963 where
6964 D: serde::Deserializer<'de>,
6965 {
6966 const FIELDS: &[&str] = &[
6967 "subscription",
6968 ];
6969
6970 #[allow(clippy::enum_variant_names)]
6971 enum GeneratedField {
6972 Subscription,
6973 }
6974 impl<'de> serde::Deserialize<'de> for GeneratedField {
6975 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6976 where
6977 D: serde::Deserializer<'de>,
6978 {
6979 struct GeneratedVisitor;
6980
6981 impl serde::de::Visitor<'_> for GeneratedVisitor {
6982 type Value = GeneratedField;
6983
6984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6985 write!(formatter, "expected one of: {:?}", &FIELDS)
6986 }
6987
6988 #[allow(unused_variables)]
6989 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6990 where
6991 E: serde::de::Error,
6992 {
6993 match value {
6994 "subscription" => Ok(GeneratedField::Subscription),
6995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6996 }
6997 }
6998 }
6999 deserializer.deserialize_identifier(GeneratedVisitor)
7000 }
7001 }
7002 struct GeneratedVisitor;
7003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7004 type Value = CreateSubscriptionRequest;
7005
7006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7007 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
7008 }
7009
7010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
7011 where
7012 V: serde::de::MapAccess<'de>,
7013 {
7014 let mut subscription__ = None;
7015 while let Some(k) = map_.next_key()? {
7016 match k {
7017 GeneratedField::Subscription => {
7018 if subscription__.is_some() {
7019 return Err(serde::de::Error::duplicate_field("subscription"));
7020 }
7021 subscription__ = map_.next_value()?;
7022 }
7023 }
7024 }
7025 Ok(CreateSubscriptionRequest {
7026 subscription: subscription__,
7027 })
7028 }
7029 }
7030 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
7031 }
7032}
7033impl serde::Serialize for CreateSubscriptionResponse {
7034 #[allow(deprecated)]
7035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7036 where
7037 S: serde::Serializer,
7038 {
7039 use serde::ser::SerializeStruct;
7040 let mut len = 0;
7041 if self.status.is_some() {
7042 len += 1;
7043 }
7044 if self.version.is_some() {
7045 len += 1;
7046 }
7047 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
7048 if let Some(v) = self.status.as_ref() {
7049 struct_ser.serialize_field("status", v)?;
7050 }
7051 if let Some(v) = self.version.as_ref() {
7052 struct_ser.serialize_field("version", v)?;
7053 }
7054 struct_ser.end()
7055 }
7056}
7057impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
7058 #[allow(deprecated)]
7059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7060 where
7061 D: serde::Deserializer<'de>,
7062 {
7063 const FIELDS: &[&str] = &[
7064 "status",
7065 "version",
7066 ];
7067
7068 #[allow(clippy::enum_variant_names)]
7069 enum GeneratedField {
7070 Status,
7071 Version,
7072 }
7073 impl<'de> serde::Deserialize<'de> for GeneratedField {
7074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7075 where
7076 D: serde::Deserializer<'de>,
7077 {
7078 struct GeneratedVisitor;
7079
7080 impl serde::de::Visitor<'_> for GeneratedVisitor {
7081 type Value = GeneratedField;
7082
7083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7084 write!(formatter, "expected one of: {:?}", &FIELDS)
7085 }
7086
7087 #[allow(unused_variables)]
7088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7089 where
7090 E: serde::de::Error,
7091 {
7092 match value {
7093 "status" => Ok(GeneratedField::Status),
7094 "version" => Ok(GeneratedField::Version),
7095 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7096 }
7097 }
7098 }
7099 deserializer.deserialize_identifier(GeneratedVisitor)
7100 }
7101 }
7102 struct GeneratedVisitor;
7103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7104 type Value = CreateSubscriptionResponse;
7105
7106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7107 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
7108 }
7109
7110 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
7111 where
7112 V: serde::de::MapAccess<'de>,
7113 {
7114 let mut status__ = None;
7115 let mut version__ = None;
7116 while let Some(k) = map_.next_key()? {
7117 match k {
7118 GeneratedField::Status => {
7119 if status__.is_some() {
7120 return Err(serde::de::Error::duplicate_field("status"));
7121 }
7122 status__ = map_.next_value()?;
7123 }
7124 GeneratedField::Version => {
7125 if version__.is_some() {
7126 return Err(serde::de::Error::duplicate_field("version"));
7127 }
7128 version__ = map_.next_value()?;
7129 }
7130 }
7131 }
7132 Ok(CreateSubscriptionResponse {
7133 status: status__,
7134 version: version__,
7135 })
7136 }
7137 }
7138 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
7139 }
7140}
7141impl serde::Serialize for CreateTableRequest {
7142 #[allow(deprecated)]
7143 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7144 where
7145 S: serde::Serializer,
7146 {
7147 use serde::ser::SerializeStruct;
7148 let mut len = 0;
7149 if self.source.is_some() {
7150 len += 1;
7151 }
7152 if self.materialized_view.is_some() {
7153 len += 1;
7154 }
7155 if self.fragment_graph.is_some() {
7156 len += 1;
7157 }
7158 if self.job_type != 0 {
7159 len += 1;
7160 }
7161 if self.if_not_exists {
7162 len += 1;
7163 }
7164 if !self.dependencies.is_empty() {
7165 len += 1;
7166 }
7167 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
7168 if let Some(v) = self.source.as_ref() {
7169 struct_ser.serialize_field("source", v)?;
7170 }
7171 if let Some(v) = self.materialized_view.as_ref() {
7172 struct_ser.serialize_field("materializedView", v)?;
7173 }
7174 if let Some(v) = self.fragment_graph.as_ref() {
7175 struct_ser.serialize_field("fragmentGraph", v)?;
7176 }
7177 if self.job_type != 0 {
7178 let v = TableJobType::try_from(self.job_type)
7179 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
7180 struct_ser.serialize_field("jobType", &v)?;
7181 }
7182 if self.if_not_exists {
7183 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7184 }
7185 if !self.dependencies.is_empty() {
7186 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7187 }
7188 struct_ser.end()
7189 }
7190}
7191impl<'de> serde::Deserialize<'de> for CreateTableRequest {
7192 #[allow(deprecated)]
7193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7194 where
7195 D: serde::Deserializer<'de>,
7196 {
7197 const FIELDS: &[&str] = &[
7198 "source",
7199 "materialized_view",
7200 "materializedView",
7201 "fragment_graph",
7202 "fragmentGraph",
7203 "job_type",
7204 "jobType",
7205 "if_not_exists",
7206 "ifNotExists",
7207 "dependencies",
7208 ];
7209
7210 #[allow(clippy::enum_variant_names)]
7211 enum GeneratedField {
7212 Source,
7213 MaterializedView,
7214 FragmentGraph,
7215 JobType,
7216 IfNotExists,
7217 Dependencies,
7218 }
7219 impl<'de> serde::Deserialize<'de> for GeneratedField {
7220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7221 where
7222 D: serde::Deserializer<'de>,
7223 {
7224 struct GeneratedVisitor;
7225
7226 impl serde::de::Visitor<'_> for GeneratedVisitor {
7227 type Value = GeneratedField;
7228
7229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7230 write!(formatter, "expected one of: {:?}", &FIELDS)
7231 }
7232
7233 #[allow(unused_variables)]
7234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7235 where
7236 E: serde::de::Error,
7237 {
7238 match value {
7239 "source" => Ok(GeneratedField::Source),
7240 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
7241 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7242 "jobType" | "job_type" => Ok(GeneratedField::JobType),
7243 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7244 "dependencies" => Ok(GeneratedField::Dependencies),
7245 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7246 }
7247 }
7248 }
7249 deserializer.deserialize_identifier(GeneratedVisitor)
7250 }
7251 }
7252 struct GeneratedVisitor;
7253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7254 type Value = CreateTableRequest;
7255
7256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7257 formatter.write_str("struct ddl_service.CreateTableRequest")
7258 }
7259
7260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
7261 where
7262 V: serde::de::MapAccess<'de>,
7263 {
7264 let mut source__ = None;
7265 let mut materialized_view__ = None;
7266 let mut fragment_graph__ = None;
7267 let mut job_type__ = None;
7268 let mut if_not_exists__ = None;
7269 let mut dependencies__ = None;
7270 while let Some(k) = map_.next_key()? {
7271 match k {
7272 GeneratedField::Source => {
7273 if source__.is_some() {
7274 return Err(serde::de::Error::duplicate_field("source"));
7275 }
7276 source__ = map_.next_value()?;
7277 }
7278 GeneratedField::MaterializedView => {
7279 if materialized_view__.is_some() {
7280 return Err(serde::de::Error::duplicate_field("materializedView"));
7281 }
7282 materialized_view__ = map_.next_value()?;
7283 }
7284 GeneratedField::FragmentGraph => {
7285 if fragment_graph__.is_some() {
7286 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7287 }
7288 fragment_graph__ = map_.next_value()?;
7289 }
7290 GeneratedField::JobType => {
7291 if job_type__.is_some() {
7292 return Err(serde::de::Error::duplicate_field("jobType"));
7293 }
7294 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
7295 }
7296 GeneratedField::IfNotExists => {
7297 if if_not_exists__.is_some() {
7298 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7299 }
7300 if_not_exists__ = Some(map_.next_value()?);
7301 }
7302 GeneratedField::Dependencies => {
7303 if dependencies__.is_some() {
7304 return Err(serde::de::Error::duplicate_field("dependencies"));
7305 }
7306 dependencies__ =
7307 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7308 .into_iter().map(|x| x.0).collect())
7309 ;
7310 }
7311 }
7312 }
7313 Ok(CreateTableRequest {
7314 source: source__,
7315 materialized_view: materialized_view__,
7316 fragment_graph: fragment_graph__,
7317 job_type: job_type__.unwrap_or_default(),
7318 if_not_exists: if_not_exists__.unwrap_or_default(),
7319 dependencies: dependencies__.unwrap_or_default(),
7320 })
7321 }
7322 }
7323 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
7324 }
7325}
7326impl serde::Serialize for CreateTableResponse {
7327 #[allow(deprecated)]
7328 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7329 where
7330 S: serde::Serializer,
7331 {
7332 use serde::ser::SerializeStruct;
7333 let mut len = 0;
7334 if self.status.is_some() {
7335 len += 1;
7336 }
7337 if self.version.is_some() {
7338 len += 1;
7339 }
7340 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
7341 if let Some(v) = self.status.as_ref() {
7342 struct_ser.serialize_field("status", v)?;
7343 }
7344 if let Some(v) = self.version.as_ref() {
7345 struct_ser.serialize_field("version", v)?;
7346 }
7347 struct_ser.end()
7348 }
7349}
7350impl<'de> serde::Deserialize<'de> for CreateTableResponse {
7351 #[allow(deprecated)]
7352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7353 where
7354 D: serde::Deserializer<'de>,
7355 {
7356 const FIELDS: &[&str] = &[
7357 "status",
7358 "version",
7359 ];
7360
7361 #[allow(clippy::enum_variant_names)]
7362 enum GeneratedField {
7363 Status,
7364 Version,
7365 }
7366 impl<'de> serde::Deserialize<'de> for GeneratedField {
7367 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7368 where
7369 D: serde::Deserializer<'de>,
7370 {
7371 struct GeneratedVisitor;
7372
7373 impl serde::de::Visitor<'_> for GeneratedVisitor {
7374 type Value = GeneratedField;
7375
7376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7377 write!(formatter, "expected one of: {:?}", &FIELDS)
7378 }
7379
7380 #[allow(unused_variables)]
7381 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7382 where
7383 E: serde::de::Error,
7384 {
7385 match value {
7386 "status" => Ok(GeneratedField::Status),
7387 "version" => Ok(GeneratedField::Version),
7388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7389 }
7390 }
7391 }
7392 deserializer.deserialize_identifier(GeneratedVisitor)
7393 }
7394 }
7395 struct GeneratedVisitor;
7396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7397 type Value = CreateTableResponse;
7398
7399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7400 formatter.write_str("struct ddl_service.CreateTableResponse")
7401 }
7402
7403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
7404 where
7405 V: serde::de::MapAccess<'de>,
7406 {
7407 let mut status__ = None;
7408 let mut version__ = None;
7409 while let Some(k) = map_.next_key()? {
7410 match k {
7411 GeneratedField::Status => {
7412 if status__.is_some() {
7413 return Err(serde::de::Error::duplicate_field("status"));
7414 }
7415 status__ = map_.next_value()?;
7416 }
7417 GeneratedField::Version => {
7418 if version__.is_some() {
7419 return Err(serde::de::Error::duplicate_field("version"));
7420 }
7421 version__ = map_.next_value()?;
7422 }
7423 }
7424 }
7425 Ok(CreateTableResponse {
7426 status: status__,
7427 version: version__,
7428 })
7429 }
7430 }
7431 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
7432 }
7433}
7434impl serde::Serialize for CreateViewRequest {
7435 #[allow(deprecated)]
7436 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7437 where
7438 S: serde::Serializer,
7439 {
7440 use serde::ser::SerializeStruct;
7441 let mut len = 0;
7442 if self.view.is_some() {
7443 len += 1;
7444 }
7445 if !self.dependencies.is_empty() {
7446 len += 1;
7447 }
7448 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
7449 if let Some(v) = self.view.as_ref() {
7450 struct_ser.serialize_field("view", v)?;
7451 }
7452 if !self.dependencies.is_empty() {
7453 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7454 }
7455 struct_ser.end()
7456 }
7457}
7458impl<'de> serde::Deserialize<'de> for CreateViewRequest {
7459 #[allow(deprecated)]
7460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7461 where
7462 D: serde::Deserializer<'de>,
7463 {
7464 const FIELDS: &[&str] = &[
7465 "view",
7466 "dependencies",
7467 ];
7468
7469 #[allow(clippy::enum_variant_names)]
7470 enum GeneratedField {
7471 View,
7472 Dependencies,
7473 }
7474 impl<'de> serde::Deserialize<'de> for GeneratedField {
7475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7476 where
7477 D: serde::Deserializer<'de>,
7478 {
7479 struct GeneratedVisitor;
7480
7481 impl serde::de::Visitor<'_> for GeneratedVisitor {
7482 type Value = GeneratedField;
7483
7484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7485 write!(formatter, "expected one of: {:?}", &FIELDS)
7486 }
7487
7488 #[allow(unused_variables)]
7489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7490 where
7491 E: serde::de::Error,
7492 {
7493 match value {
7494 "view" => Ok(GeneratedField::View),
7495 "dependencies" => Ok(GeneratedField::Dependencies),
7496 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7497 }
7498 }
7499 }
7500 deserializer.deserialize_identifier(GeneratedVisitor)
7501 }
7502 }
7503 struct GeneratedVisitor;
7504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7505 type Value = CreateViewRequest;
7506
7507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7508 formatter.write_str("struct ddl_service.CreateViewRequest")
7509 }
7510
7511 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7512 where
7513 V: serde::de::MapAccess<'de>,
7514 {
7515 let mut view__ = None;
7516 let mut dependencies__ = None;
7517 while let Some(k) = map_.next_key()? {
7518 match k {
7519 GeneratedField::View => {
7520 if view__.is_some() {
7521 return Err(serde::de::Error::duplicate_field("view"));
7522 }
7523 view__ = map_.next_value()?;
7524 }
7525 GeneratedField::Dependencies => {
7526 if dependencies__.is_some() {
7527 return Err(serde::de::Error::duplicate_field("dependencies"));
7528 }
7529 dependencies__ =
7530 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7531 .into_iter().map(|x| x.0).collect())
7532 ;
7533 }
7534 }
7535 }
7536 Ok(CreateViewRequest {
7537 view: view__,
7538 dependencies: dependencies__.unwrap_or_default(),
7539 })
7540 }
7541 }
7542 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7543 }
7544}
7545impl serde::Serialize for CreateViewResponse {
7546 #[allow(deprecated)]
7547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7548 where
7549 S: serde::Serializer,
7550 {
7551 use serde::ser::SerializeStruct;
7552 let mut len = 0;
7553 if self.status.is_some() {
7554 len += 1;
7555 }
7556 if self.version.is_some() {
7557 len += 1;
7558 }
7559 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7560 if let Some(v) = self.status.as_ref() {
7561 struct_ser.serialize_field("status", v)?;
7562 }
7563 if let Some(v) = self.version.as_ref() {
7564 struct_ser.serialize_field("version", v)?;
7565 }
7566 struct_ser.end()
7567 }
7568}
7569impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7570 #[allow(deprecated)]
7571 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7572 where
7573 D: serde::Deserializer<'de>,
7574 {
7575 const FIELDS: &[&str] = &[
7576 "status",
7577 "version",
7578 ];
7579
7580 #[allow(clippy::enum_variant_names)]
7581 enum GeneratedField {
7582 Status,
7583 Version,
7584 }
7585 impl<'de> serde::Deserialize<'de> for GeneratedField {
7586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7587 where
7588 D: serde::Deserializer<'de>,
7589 {
7590 struct GeneratedVisitor;
7591
7592 impl serde::de::Visitor<'_> for GeneratedVisitor {
7593 type Value = GeneratedField;
7594
7595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7596 write!(formatter, "expected one of: {:?}", &FIELDS)
7597 }
7598
7599 #[allow(unused_variables)]
7600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7601 where
7602 E: serde::de::Error,
7603 {
7604 match value {
7605 "status" => Ok(GeneratedField::Status),
7606 "version" => Ok(GeneratedField::Version),
7607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7608 }
7609 }
7610 }
7611 deserializer.deserialize_identifier(GeneratedVisitor)
7612 }
7613 }
7614 struct GeneratedVisitor;
7615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7616 type Value = CreateViewResponse;
7617
7618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7619 formatter.write_str("struct ddl_service.CreateViewResponse")
7620 }
7621
7622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7623 where
7624 V: serde::de::MapAccess<'de>,
7625 {
7626 let mut status__ = None;
7627 let mut version__ = None;
7628 while let Some(k) = map_.next_key()? {
7629 match k {
7630 GeneratedField::Status => {
7631 if status__.is_some() {
7632 return Err(serde::de::Error::duplicate_field("status"));
7633 }
7634 status__ = map_.next_value()?;
7635 }
7636 GeneratedField::Version => {
7637 if version__.is_some() {
7638 return Err(serde::de::Error::duplicate_field("version"));
7639 }
7640 version__ = map_.next_value()?;
7641 }
7642 }
7643 }
7644 Ok(CreateViewResponse {
7645 status: status__,
7646 version: version__,
7647 })
7648 }
7649 }
7650 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7651 }
7652}
7653impl serde::Serialize for DdlProgress {
7654 #[allow(deprecated)]
7655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7656 where
7657 S: serde::Serializer,
7658 {
7659 use serde::ser::SerializeStruct;
7660 let mut len = 0;
7661 if self.id != 0 {
7662 len += 1;
7663 }
7664 if !self.statement.is_empty() {
7665 len += 1;
7666 }
7667 if !self.progress.is_empty() {
7668 len += 1;
7669 }
7670 if !self.create_type.is_empty() {
7671 len += 1;
7672 }
7673 if self.initialized_at_time_millis != 0 {
7674 len += 1;
7675 }
7676 if self.is_serverless_backfill {
7677 len += 1;
7678 }
7679 if self.backfill_type != 0 {
7680 len += 1;
7681 }
7682 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
7683 if self.id != 0 {
7684 #[allow(clippy::needless_borrow)]
7685 #[allow(clippy::needless_borrows_for_generic_args)]
7686 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7687 }
7688 if !self.statement.is_empty() {
7689 struct_ser.serialize_field("statement", &self.statement)?;
7690 }
7691 if !self.progress.is_empty() {
7692 struct_ser.serialize_field("progress", &self.progress)?;
7693 }
7694 if !self.create_type.is_empty() {
7695 struct_ser.serialize_field("createType", &self.create_type)?;
7696 }
7697 if self.initialized_at_time_millis != 0 {
7698 #[allow(clippy::needless_borrow)]
7699 #[allow(clippy::needless_borrows_for_generic_args)]
7700 struct_ser.serialize_field("initializedAtTimeMillis", ToString::to_string(&self.initialized_at_time_millis).as_str())?;
7701 }
7702 if self.is_serverless_backfill {
7703 struct_ser.serialize_field("isServerlessBackfill", &self.is_serverless_backfill)?;
7704 }
7705 if self.backfill_type != 0 {
7706 let v = BackfillType::try_from(self.backfill_type)
7707 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill_type)))?;
7708 struct_ser.serialize_field("backfillType", &v)?;
7709 }
7710 struct_ser.end()
7711 }
7712}
7713impl<'de> serde::Deserialize<'de> for DdlProgress {
7714 #[allow(deprecated)]
7715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7716 where
7717 D: serde::Deserializer<'de>,
7718 {
7719 const FIELDS: &[&str] = &[
7720 "id",
7721 "statement",
7722 "progress",
7723 "create_type",
7724 "createType",
7725 "initialized_at_time_millis",
7726 "initializedAtTimeMillis",
7727 "is_serverless_backfill",
7728 "isServerlessBackfill",
7729 "backfill_type",
7730 "backfillType",
7731 ];
7732
7733 #[allow(clippy::enum_variant_names)]
7734 enum GeneratedField {
7735 Id,
7736 Statement,
7737 Progress,
7738 CreateType,
7739 InitializedAtTimeMillis,
7740 IsServerlessBackfill,
7741 BackfillType,
7742 }
7743 impl<'de> serde::Deserialize<'de> for GeneratedField {
7744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7745 where
7746 D: serde::Deserializer<'de>,
7747 {
7748 struct GeneratedVisitor;
7749
7750 impl serde::de::Visitor<'_> for GeneratedVisitor {
7751 type Value = GeneratedField;
7752
7753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7754 write!(formatter, "expected one of: {:?}", &FIELDS)
7755 }
7756
7757 #[allow(unused_variables)]
7758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7759 where
7760 E: serde::de::Error,
7761 {
7762 match value {
7763 "id" => Ok(GeneratedField::Id),
7764 "statement" => Ok(GeneratedField::Statement),
7765 "progress" => Ok(GeneratedField::Progress),
7766 "createType" | "create_type" => Ok(GeneratedField::CreateType),
7767 "initializedAtTimeMillis" | "initialized_at_time_millis" => Ok(GeneratedField::InitializedAtTimeMillis),
7768 "isServerlessBackfill" | "is_serverless_backfill" => Ok(GeneratedField::IsServerlessBackfill),
7769 "backfillType" | "backfill_type" => Ok(GeneratedField::BackfillType),
7770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7771 }
7772 }
7773 }
7774 deserializer.deserialize_identifier(GeneratedVisitor)
7775 }
7776 }
7777 struct GeneratedVisitor;
7778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7779 type Value = DdlProgress;
7780
7781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7782 formatter.write_str("struct ddl_service.DdlProgress")
7783 }
7784
7785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
7786 where
7787 V: serde::de::MapAccess<'de>,
7788 {
7789 let mut id__ = None;
7790 let mut statement__ = None;
7791 let mut progress__ = None;
7792 let mut create_type__ = None;
7793 let mut initialized_at_time_millis__ = None;
7794 let mut is_serverless_backfill__ = None;
7795 let mut backfill_type__ = None;
7796 while let Some(k) = map_.next_key()? {
7797 match k {
7798 GeneratedField::Id => {
7799 if id__.is_some() {
7800 return Err(serde::de::Error::duplicate_field("id"));
7801 }
7802 id__ =
7803 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7804 ;
7805 }
7806 GeneratedField::Statement => {
7807 if statement__.is_some() {
7808 return Err(serde::de::Error::duplicate_field("statement"));
7809 }
7810 statement__ = Some(map_.next_value()?);
7811 }
7812 GeneratedField::Progress => {
7813 if progress__.is_some() {
7814 return Err(serde::de::Error::duplicate_field("progress"));
7815 }
7816 progress__ = Some(map_.next_value()?);
7817 }
7818 GeneratedField::CreateType => {
7819 if create_type__.is_some() {
7820 return Err(serde::de::Error::duplicate_field("createType"));
7821 }
7822 create_type__ = Some(map_.next_value()?);
7823 }
7824 GeneratedField::InitializedAtTimeMillis => {
7825 if initialized_at_time_millis__.is_some() {
7826 return Err(serde::de::Error::duplicate_field("initializedAtTimeMillis"));
7827 }
7828 initialized_at_time_millis__ =
7829 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7830 ;
7831 }
7832 GeneratedField::IsServerlessBackfill => {
7833 if is_serverless_backfill__.is_some() {
7834 return Err(serde::de::Error::duplicate_field("isServerlessBackfill"));
7835 }
7836 is_serverless_backfill__ = Some(map_.next_value()?);
7837 }
7838 GeneratedField::BackfillType => {
7839 if backfill_type__.is_some() {
7840 return Err(serde::de::Error::duplicate_field("backfillType"));
7841 }
7842 backfill_type__ = Some(map_.next_value::<BackfillType>()? as i32);
7843 }
7844 }
7845 }
7846 Ok(DdlProgress {
7847 id: id__.unwrap_or_default(),
7848 statement: statement__.unwrap_or_default(),
7849 progress: progress__.unwrap_or_default(),
7850 create_type: create_type__.unwrap_or_default(),
7851 initialized_at_time_millis: initialized_at_time_millis__.unwrap_or_default(),
7852 is_serverless_backfill: is_serverless_backfill__.unwrap_or_default(),
7853 backfill_type: backfill_type__.unwrap_or_default(),
7854 })
7855 }
7856 }
7857 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
7858 }
7859}
7860impl serde::Serialize for DropConnectionRequest {
7861 #[allow(deprecated)]
7862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7863 where
7864 S: serde::Serializer,
7865 {
7866 use serde::ser::SerializeStruct;
7867 let mut len = 0;
7868 if self.connection_id != 0 {
7869 len += 1;
7870 }
7871 if self.cascade {
7872 len += 1;
7873 }
7874 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
7875 if self.connection_id != 0 {
7876 struct_ser.serialize_field("connectionId", &self.connection_id)?;
7877 }
7878 if self.cascade {
7879 struct_ser.serialize_field("cascade", &self.cascade)?;
7880 }
7881 struct_ser.end()
7882 }
7883}
7884impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
7885 #[allow(deprecated)]
7886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7887 where
7888 D: serde::Deserializer<'de>,
7889 {
7890 const FIELDS: &[&str] = &[
7891 "connection_id",
7892 "connectionId",
7893 "cascade",
7894 ];
7895
7896 #[allow(clippy::enum_variant_names)]
7897 enum GeneratedField {
7898 ConnectionId,
7899 Cascade,
7900 }
7901 impl<'de> serde::Deserialize<'de> for GeneratedField {
7902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7903 where
7904 D: serde::Deserializer<'de>,
7905 {
7906 struct GeneratedVisitor;
7907
7908 impl serde::de::Visitor<'_> for GeneratedVisitor {
7909 type Value = GeneratedField;
7910
7911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7912 write!(formatter, "expected one of: {:?}", &FIELDS)
7913 }
7914
7915 #[allow(unused_variables)]
7916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7917 where
7918 E: serde::de::Error,
7919 {
7920 match value {
7921 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
7922 "cascade" => Ok(GeneratedField::Cascade),
7923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7924 }
7925 }
7926 }
7927 deserializer.deserialize_identifier(GeneratedVisitor)
7928 }
7929 }
7930 struct GeneratedVisitor;
7931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7932 type Value = DropConnectionRequest;
7933
7934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7935 formatter.write_str("struct ddl_service.DropConnectionRequest")
7936 }
7937
7938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
7939 where
7940 V: serde::de::MapAccess<'de>,
7941 {
7942 let mut connection_id__ = None;
7943 let mut cascade__ = None;
7944 while let Some(k) = map_.next_key()? {
7945 match k {
7946 GeneratedField::ConnectionId => {
7947 if connection_id__.is_some() {
7948 return Err(serde::de::Error::duplicate_field("connectionId"));
7949 }
7950 connection_id__ =
7951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7952 ;
7953 }
7954 GeneratedField::Cascade => {
7955 if cascade__.is_some() {
7956 return Err(serde::de::Error::duplicate_field("cascade"));
7957 }
7958 cascade__ = Some(map_.next_value()?);
7959 }
7960 }
7961 }
7962 Ok(DropConnectionRequest {
7963 connection_id: connection_id__.unwrap_or_default(),
7964 cascade: cascade__.unwrap_or_default(),
7965 })
7966 }
7967 }
7968 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
7969 }
7970}
7971impl serde::Serialize for DropConnectionResponse {
7972 #[allow(deprecated)]
7973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7974 where
7975 S: serde::Serializer,
7976 {
7977 use serde::ser::SerializeStruct;
7978 let mut len = 0;
7979 if self.status.is_some() {
7980 len += 1;
7981 }
7982 if self.version.is_some() {
7983 len += 1;
7984 }
7985 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
7986 if let Some(v) = self.status.as_ref() {
7987 struct_ser.serialize_field("status", v)?;
7988 }
7989 if let Some(v) = self.version.as_ref() {
7990 struct_ser.serialize_field("version", v)?;
7991 }
7992 struct_ser.end()
7993 }
7994}
7995impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
7996 #[allow(deprecated)]
7997 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7998 where
7999 D: serde::Deserializer<'de>,
8000 {
8001 const FIELDS: &[&str] = &[
8002 "status",
8003 "version",
8004 ];
8005
8006 #[allow(clippy::enum_variant_names)]
8007 enum GeneratedField {
8008 Status,
8009 Version,
8010 }
8011 impl<'de> serde::Deserialize<'de> for GeneratedField {
8012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8013 where
8014 D: serde::Deserializer<'de>,
8015 {
8016 struct GeneratedVisitor;
8017
8018 impl serde::de::Visitor<'_> for GeneratedVisitor {
8019 type Value = GeneratedField;
8020
8021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8022 write!(formatter, "expected one of: {:?}", &FIELDS)
8023 }
8024
8025 #[allow(unused_variables)]
8026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8027 where
8028 E: serde::de::Error,
8029 {
8030 match value {
8031 "status" => Ok(GeneratedField::Status),
8032 "version" => Ok(GeneratedField::Version),
8033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8034 }
8035 }
8036 }
8037 deserializer.deserialize_identifier(GeneratedVisitor)
8038 }
8039 }
8040 struct GeneratedVisitor;
8041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8042 type Value = DropConnectionResponse;
8043
8044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8045 formatter.write_str("struct ddl_service.DropConnectionResponse")
8046 }
8047
8048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
8049 where
8050 V: serde::de::MapAccess<'de>,
8051 {
8052 let mut status__ = None;
8053 let mut version__ = None;
8054 while let Some(k) = map_.next_key()? {
8055 match k {
8056 GeneratedField::Status => {
8057 if status__.is_some() {
8058 return Err(serde::de::Error::duplicate_field("status"));
8059 }
8060 status__ = map_.next_value()?;
8061 }
8062 GeneratedField::Version => {
8063 if version__.is_some() {
8064 return Err(serde::de::Error::duplicate_field("version"));
8065 }
8066 version__ = map_.next_value()?;
8067 }
8068 }
8069 }
8070 Ok(DropConnectionResponse {
8071 status: status__,
8072 version: version__,
8073 })
8074 }
8075 }
8076 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
8077 }
8078}
8079impl serde::Serialize for DropDatabaseRequest {
8080 #[allow(deprecated)]
8081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8082 where
8083 S: serde::Serializer,
8084 {
8085 use serde::ser::SerializeStruct;
8086 let mut len = 0;
8087 if self.database_id != 0 {
8088 len += 1;
8089 }
8090 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
8091 if self.database_id != 0 {
8092 struct_ser.serialize_field("databaseId", &self.database_id)?;
8093 }
8094 struct_ser.end()
8095 }
8096}
8097impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
8098 #[allow(deprecated)]
8099 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8100 where
8101 D: serde::Deserializer<'de>,
8102 {
8103 const FIELDS: &[&str] = &[
8104 "database_id",
8105 "databaseId",
8106 ];
8107
8108 #[allow(clippy::enum_variant_names)]
8109 enum GeneratedField {
8110 DatabaseId,
8111 }
8112 impl<'de> serde::Deserialize<'de> for GeneratedField {
8113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8114 where
8115 D: serde::Deserializer<'de>,
8116 {
8117 struct GeneratedVisitor;
8118
8119 impl serde::de::Visitor<'_> for GeneratedVisitor {
8120 type Value = GeneratedField;
8121
8122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8123 write!(formatter, "expected one of: {:?}", &FIELDS)
8124 }
8125
8126 #[allow(unused_variables)]
8127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8128 where
8129 E: serde::de::Error,
8130 {
8131 match value {
8132 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
8133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8134 }
8135 }
8136 }
8137 deserializer.deserialize_identifier(GeneratedVisitor)
8138 }
8139 }
8140 struct GeneratedVisitor;
8141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8142 type Value = DropDatabaseRequest;
8143
8144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8145 formatter.write_str("struct ddl_service.DropDatabaseRequest")
8146 }
8147
8148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
8149 where
8150 V: serde::de::MapAccess<'de>,
8151 {
8152 let mut database_id__ = None;
8153 while let Some(k) = map_.next_key()? {
8154 match k {
8155 GeneratedField::DatabaseId => {
8156 if database_id__.is_some() {
8157 return Err(serde::de::Error::duplicate_field("databaseId"));
8158 }
8159 database_id__ =
8160 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8161 ;
8162 }
8163 }
8164 }
8165 Ok(DropDatabaseRequest {
8166 database_id: database_id__.unwrap_or_default(),
8167 })
8168 }
8169 }
8170 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
8171 }
8172}
8173impl serde::Serialize for DropDatabaseResponse {
8174 #[allow(deprecated)]
8175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8176 where
8177 S: serde::Serializer,
8178 {
8179 use serde::ser::SerializeStruct;
8180 let mut len = 0;
8181 if self.status.is_some() {
8182 len += 1;
8183 }
8184 if self.version.is_some() {
8185 len += 1;
8186 }
8187 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
8188 if let Some(v) = self.status.as_ref() {
8189 struct_ser.serialize_field("status", v)?;
8190 }
8191 if let Some(v) = self.version.as_ref() {
8192 struct_ser.serialize_field("version", v)?;
8193 }
8194 struct_ser.end()
8195 }
8196}
8197impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
8198 #[allow(deprecated)]
8199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8200 where
8201 D: serde::Deserializer<'de>,
8202 {
8203 const FIELDS: &[&str] = &[
8204 "status",
8205 "version",
8206 ];
8207
8208 #[allow(clippy::enum_variant_names)]
8209 enum GeneratedField {
8210 Status,
8211 Version,
8212 }
8213 impl<'de> serde::Deserialize<'de> for GeneratedField {
8214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8215 where
8216 D: serde::Deserializer<'de>,
8217 {
8218 struct GeneratedVisitor;
8219
8220 impl serde::de::Visitor<'_> for GeneratedVisitor {
8221 type Value = GeneratedField;
8222
8223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8224 write!(formatter, "expected one of: {:?}", &FIELDS)
8225 }
8226
8227 #[allow(unused_variables)]
8228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8229 where
8230 E: serde::de::Error,
8231 {
8232 match value {
8233 "status" => Ok(GeneratedField::Status),
8234 "version" => Ok(GeneratedField::Version),
8235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8236 }
8237 }
8238 }
8239 deserializer.deserialize_identifier(GeneratedVisitor)
8240 }
8241 }
8242 struct GeneratedVisitor;
8243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8244 type Value = DropDatabaseResponse;
8245
8246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8247 formatter.write_str("struct ddl_service.DropDatabaseResponse")
8248 }
8249
8250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
8251 where
8252 V: serde::de::MapAccess<'de>,
8253 {
8254 let mut status__ = None;
8255 let mut version__ = None;
8256 while let Some(k) = map_.next_key()? {
8257 match k {
8258 GeneratedField::Status => {
8259 if status__.is_some() {
8260 return Err(serde::de::Error::duplicate_field("status"));
8261 }
8262 status__ = map_.next_value()?;
8263 }
8264 GeneratedField::Version => {
8265 if version__.is_some() {
8266 return Err(serde::de::Error::duplicate_field("version"));
8267 }
8268 version__ = map_.next_value()?;
8269 }
8270 }
8271 }
8272 Ok(DropDatabaseResponse {
8273 status: status__,
8274 version: version__,
8275 })
8276 }
8277 }
8278 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
8279 }
8280}
8281impl serde::Serialize for DropFunctionRequest {
8282 #[allow(deprecated)]
8283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8284 where
8285 S: serde::Serializer,
8286 {
8287 use serde::ser::SerializeStruct;
8288 let mut len = 0;
8289 if self.function_id != 0 {
8290 len += 1;
8291 }
8292 if self.cascade {
8293 len += 1;
8294 }
8295 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
8296 if self.function_id != 0 {
8297 struct_ser.serialize_field("functionId", &self.function_id)?;
8298 }
8299 if self.cascade {
8300 struct_ser.serialize_field("cascade", &self.cascade)?;
8301 }
8302 struct_ser.end()
8303 }
8304}
8305impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
8306 #[allow(deprecated)]
8307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8308 where
8309 D: serde::Deserializer<'de>,
8310 {
8311 const FIELDS: &[&str] = &[
8312 "function_id",
8313 "functionId",
8314 "cascade",
8315 ];
8316
8317 #[allow(clippy::enum_variant_names)]
8318 enum GeneratedField {
8319 FunctionId,
8320 Cascade,
8321 }
8322 impl<'de> serde::Deserialize<'de> for GeneratedField {
8323 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8324 where
8325 D: serde::Deserializer<'de>,
8326 {
8327 struct GeneratedVisitor;
8328
8329 impl serde::de::Visitor<'_> for GeneratedVisitor {
8330 type Value = GeneratedField;
8331
8332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8333 write!(formatter, "expected one of: {:?}", &FIELDS)
8334 }
8335
8336 #[allow(unused_variables)]
8337 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8338 where
8339 E: serde::de::Error,
8340 {
8341 match value {
8342 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
8343 "cascade" => Ok(GeneratedField::Cascade),
8344 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8345 }
8346 }
8347 }
8348 deserializer.deserialize_identifier(GeneratedVisitor)
8349 }
8350 }
8351 struct GeneratedVisitor;
8352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8353 type Value = DropFunctionRequest;
8354
8355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8356 formatter.write_str("struct ddl_service.DropFunctionRequest")
8357 }
8358
8359 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
8360 where
8361 V: serde::de::MapAccess<'de>,
8362 {
8363 let mut function_id__ = None;
8364 let mut cascade__ = None;
8365 while let Some(k) = map_.next_key()? {
8366 match k {
8367 GeneratedField::FunctionId => {
8368 if function_id__.is_some() {
8369 return Err(serde::de::Error::duplicate_field("functionId"));
8370 }
8371 function_id__ =
8372 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8373 ;
8374 }
8375 GeneratedField::Cascade => {
8376 if cascade__.is_some() {
8377 return Err(serde::de::Error::duplicate_field("cascade"));
8378 }
8379 cascade__ = Some(map_.next_value()?);
8380 }
8381 }
8382 }
8383 Ok(DropFunctionRequest {
8384 function_id: function_id__.unwrap_or_default(),
8385 cascade: cascade__.unwrap_or_default(),
8386 })
8387 }
8388 }
8389 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
8390 }
8391}
8392impl serde::Serialize for DropFunctionResponse {
8393 #[allow(deprecated)]
8394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8395 where
8396 S: serde::Serializer,
8397 {
8398 use serde::ser::SerializeStruct;
8399 let mut len = 0;
8400 if self.status.is_some() {
8401 len += 1;
8402 }
8403 if self.version.is_some() {
8404 len += 1;
8405 }
8406 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
8407 if let Some(v) = self.status.as_ref() {
8408 struct_ser.serialize_field("status", v)?;
8409 }
8410 if let Some(v) = self.version.as_ref() {
8411 struct_ser.serialize_field("version", v)?;
8412 }
8413 struct_ser.end()
8414 }
8415}
8416impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
8417 #[allow(deprecated)]
8418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8419 where
8420 D: serde::Deserializer<'de>,
8421 {
8422 const FIELDS: &[&str] = &[
8423 "status",
8424 "version",
8425 ];
8426
8427 #[allow(clippy::enum_variant_names)]
8428 enum GeneratedField {
8429 Status,
8430 Version,
8431 }
8432 impl<'de> serde::Deserialize<'de> for GeneratedField {
8433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8434 where
8435 D: serde::Deserializer<'de>,
8436 {
8437 struct GeneratedVisitor;
8438
8439 impl serde::de::Visitor<'_> for GeneratedVisitor {
8440 type Value = GeneratedField;
8441
8442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8443 write!(formatter, "expected one of: {:?}", &FIELDS)
8444 }
8445
8446 #[allow(unused_variables)]
8447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8448 where
8449 E: serde::de::Error,
8450 {
8451 match value {
8452 "status" => Ok(GeneratedField::Status),
8453 "version" => Ok(GeneratedField::Version),
8454 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8455 }
8456 }
8457 }
8458 deserializer.deserialize_identifier(GeneratedVisitor)
8459 }
8460 }
8461 struct GeneratedVisitor;
8462 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8463 type Value = DropFunctionResponse;
8464
8465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8466 formatter.write_str("struct ddl_service.DropFunctionResponse")
8467 }
8468
8469 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
8470 where
8471 V: serde::de::MapAccess<'de>,
8472 {
8473 let mut status__ = None;
8474 let mut version__ = None;
8475 while let Some(k) = map_.next_key()? {
8476 match k {
8477 GeneratedField::Status => {
8478 if status__.is_some() {
8479 return Err(serde::de::Error::duplicate_field("status"));
8480 }
8481 status__ = map_.next_value()?;
8482 }
8483 GeneratedField::Version => {
8484 if version__.is_some() {
8485 return Err(serde::de::Error::duplicate_field("version"));
8486 }
8487 version__ = map_.next_value()?;
8488 }
8489 }
8490 }
8491 Ok(DropFunctionResponse {
8492 status: status__,
8493 version: version__,
8494 })
8495 }
8496 }
8497 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
8498 }
8499}
8500impl serde::Serialize for DropIndexRequest {
8501 #[allow(deprecated)]
8502 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8503 where
8504 S: serde::Serializer,
8505 {
8506 use serde::ser::SerializeStruct;
8507 let mut len = 0;
8508 if self.index_id != 0 {
8509 len += 1;
8510 }
8511 if self.cascade {
8512 len += 1;
8513 }
8514 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
8515 if self.index_id != 0 {
8516 struct_ser.serialize_field("indexId", &self.index_id)?;
8517 }
8518 if self.cascade {
8519 struct_ser.serialize_field("cascade", &self.cascade)?;
8520 }
8521 struct_ser.end()
8522 }
8523}
8524impl<'de> serde::Deserialize<'de> for DropIndexRequest {
8525 #[allow(deprecated)]
8526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8527 where
8528 D: serde::Deserializer<'de>,
8529 {
8530 const FIELDS: &[&str] = &[
8531 "index_id",
8532 "indexId",
8533 "cascade",
8534 ];
8535
8536 #[allow(clippy::enum_variant_names)]
8537 enum GeneratedField {
8538 IndexId,
8539 Cascade,
8540 }
8541 impl<'de> serde::Deserialize<'de> for GeneratedField {
8542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8543 where
8544 D: serde::Deserializer<'de>,
8545 {
8546 struct GeneratedVisitor;
8547
8548 impl serde::de::Visitor<'_> for GeneratedVisitor {
8549 type Value = GeneratedField;
8550
8551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8552 write!(formatter, "expected one of: {:?}", &FIELDS)
8553 }
8554
8555 #[allow(unused_variables)]
8556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8557 where
8558 E: serde::de::Error,
8559 {
8560 match value {
8561 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8562 "cascade" => Ok(GeneratedField::Cascade),
8563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8564 }
8565 }
8566 }
8567 deserializer.deserialize_identifier(GeneratedVisitor)
8568 }
8569 }
8570 struct GeneratedVisitor;
8571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8572 type Value = DropIndexRequest;
8573
8574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8575 formatter.write_str("struct ddl_service.DropIndexRequest")
8576 }
8577
8578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8579 where
8580 V: serde::de::MapAccess<'de>,
8581 {
8582 let mut index_id__ = None;
8583 let mut cascade__ = None;
8584 while let Some(k) = map_.next_key()? {
8585 match k {
8586 GeneratedField::IndexId => {
8587 if index_id__.is_some() {
8588 return Err(serde::de::Error::duplicate_field("indexId"));
8589 }
8590 index_id__ =
8591 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8592 ;
8593 }
8594 GeneratedField::Cascade => {
8595 if cascade__.is_some() {
8596 return Err(serde::de::Error::duplicate_field("cascade"));
8597 }
8598 cascade__ = Some(map_.next_value()?);
8599 }
8600 }
8601 }
8602 Ok(DropIndexRequest {
8603 index_id: index_id__.unwrap_or_default(),
8604 cascade: cascade__.unwrap_or_default(),
8605 })
8606 }
8607 }
8608 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8609 }
8610}
8611impl serde::Serialize for DropIndexResponse {
8612 #[allow(deprecated)]
8613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8614 where
8615 S: serde::Serializer,
8616 {
8617 use serde::ser::SerializeStruct;
8618 let mut len = 0;
8619 if self.status.is_some() {
8620 len += 1;
8621 }
8622 if self.version.is_some() {
8623 len += 1;
8624 }
8625 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8626 if let Some(v) = self.status.as_ref() {
8627 struct_ser.serialize_field("status", v)?;
8628 }
8629 if let Some(v) = self.version.as_ref() {
8630 struct_ser.serialize_field("version", v)?;
8631 }
8632 struct_ser.end()
8633 }
8634}
8635impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8636 #[allow(deprecated)]
8637 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8638 where
8639 D: serde::Deserializer<'de>,
8640 {
8641 const FIELDS: &[&str] = &[
8642 "status",
8643 "version",
8644 ];
8645
8646 #[allow(clippy::enum_variant_names)]
8647 enum GeneratedField {
8648 Status,
8649 Version,
8650 }
8651 impl<'de> serde::Deserialize<'de> for GeneratedField {
8652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8653 where
8654 D: serde::Deserializer<'de>,
8655 {
8656 struct GeneratedVisitor;
8657
8658 impl serde::de::Visitor<'_> for GeneratedVisitor {
8659 type Value = GeneratedField;
8660
8661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8662 write!(formatter, "expected one of: {:?}", &FIELDS)
8663 }
8664
8665 #[allow(unused_variables)]
8666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8667 where
8668 E: serde::de::Error,
8669 {
8670 match value {
8671 "status" => Ok(GeneratedField::Status),
8672 "version" => Ok(GeneratedField::Version),
8673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8674 }
8675 }
8676 }
8677 deserializer.deserialize_identifier(GeneratedVisitor)
8678 }
8679 }
8680 struct GeneratedVisitor;
8681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8682 type Value = DropIndexResponse;
8683
8684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8685 formatter.write_str("struct ddl_service.DropIndexResponse")
8686 }
8687
8688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
8689 where
8690 V: serde::de::MapAccess<'de>,
8691 {
8692 let mut status__ = None;
8693 let mut version__ = None;
8694 while let Some(k) = map_.next_key()? {
8695 match k {
8696 GeneratedField::Status => {
8697 if status__.is_some() {
8698 return Err(serde::de::Error::duplicate_field("status"));
8699 }
8700 status__ = map_.next_value()?;
8701 }
8702 GeneratedField::Version => {
8703 if version__.is_some() {
8704 return Err(serde::de::Error::duplicate_field("version"));
8705 }
8706 version__ = map_.next_value()?;
8707 }
8708 }
8709 }
8710 Ok(DropIndexResponse {
8711 status: status__,
8712 version: version__,
8713 })
8714 }
8715 }
8716 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
8717 }
8718}
8719impl serde::Serialize for DropMaterializedViewRequest {
8720 #[allow(deprecated)]
8721 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8722 where
8723 S: serde::Serializer,
8724 {
8725 use serde::ser::SerializeStruct;
8726 let mut len = 0;
8727 if self.table_id != 0 {
8728 len += 1;
8729 }
8730 if self.cascade {
8731 len += 1;
8732 }
8733 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
8734 if self.table_id != 0 {
8735 struct_ser.serialize_field("tableId", &self.table_id)?;
8736 }
8737 if self.cascade {
8738 struct_ser.serialize_field("cascade", &self.cascade)?;
8739 }
8740 struct_ser.end()
8741 }
8742}
8743impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
8744 #[allow(deprecated)]
8745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8746 where
8747 D: serde::Deserializer<'de>,
8748 {
8749 const FIELDS: &[&str] = &[
8750 "table_id",
8751 "tableId",
8752 "cascade",
8753 ];
8754
8755 #[allow(clippy::enum_variant_names)]
8756 enum GeneratedField {
8757 TableId,
8758 Cascade,
8759 }
8760 impl<'de> serde::Deserialize<'de> for GeneratedField {
8761 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8762 where
8763 D: serde::Deserializer<'de>,
8764 {
8765 struct GeneratedVisitor;
8766
8767 impl serde::de::Visitor<'_> for GeneratedVisitor {
8768 type Value = GeneratedField;
8769
8770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8771 write!(formatter, "expected one of: {:?}", &FIELDS)
8772 }
8773
8774 #[allow(unused_variables)]
8775 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8776 where
8777 E: serde::de::Error,
8778 {
8779 match value {
8780 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8781 "cascade" => Ok(GeneratedField::Cascade),
8782 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8783 }
8784 }
8785 }
8786 deserializer.deserialize_identifier(GeneratedVisitor)
8787 }
8788 }
8789 struct GeneratedVisitor;
8790 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8791 type Value = DropMaterializedViewRequest;
8792
8793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8794 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
8795 }
8796
8797 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
8798 where
8799 V: serde::de::MapAccess<'de>,
8800 {
8801 let mut table_id__ = None;
8802 let mut cascade__ = None;
8803 while let Some(k) = map_.next_key()? {
8804 match k {
8805 GeneratedField::TableId => {
8806 if table_id__.is_some() {
8807 return Err(serde::de::Error::duplicate_field("tableId"));
8808 }
8809 table_id__ =
8810 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8811 ;
8812 }
8813 GeneratedField::Cascade => {
8814 if cascade__.is_some() {
8815 return Err(serde::de::Error::duplicate_field("cascade"));
8816 }
8817 cascade__ = Some(map_.next_value()?);
8818 }
8819 }
8820 }
8821 Ok(DropMaterializedViewRequest {
8822 table_id: table_id__.unwrap_or_default(),
8823 cascade: cascade__.unwrap_or_default(),
8824 })
8825 }
8826 }
8827 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
8828 }
8829}
8830impl serde::Serialize for DropMaterializedViewResponse {
8831 #[allow(deprecated)]
8832 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8833 where
8834 S: serde::Serializer,
8835 {
8836 use serde::ser::SerializeStruct;
8837 let mut len = 0;
8838 if self.status.is_some() {
8839 len += 1;
8840 }
8841 if self.version.is_some() {
8842 len += 1;
8843 }
8844 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
8845 if let Some(v) = self.status.as_ref() {
8846 struct_ser.serialize_field("status", v)?;
8847 }
8848 if let Some(v) = self.version.as_ref() {
8849 struct_ser.serialize_field("version", v)?;
8850 }
8851 struct_ser.end()
8852 }
8853}
8854impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
8855 #[allow(deprecated)]
8856 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8857 where
8858 D: serde::Deserializer<'de>,
8859 {
8860 const FIELDS: &[&str] = &[
8861 "status",
8862 "version",
8863 ];
8864
8865 #[allow(clippy::enum_variant_names)]
8866 enum GeneratedField {
8867 Status,
8868 Version,
8869 }
8870 impl<'de> serde::Deserialize<'de> for GeneratedField {
8871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8872 where
8873 D: serde::Deserializer<'de>,
8874 {
8875 struct GeneratedVisitor;
8876
8877 impl serde::de::Visitor<'_> for GeneratedVisitor {
8878 type Value = GeneratedField;
8879
8880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8881 write!(formatter, "expected one of: {:?}", &FIELDS)
8882 }
8883
8884 #[allow(unused_variables)]
8885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8886 where
8887 E: serde::de::Error,
8888 {
8889 match value {
8890 "status" => Ok(GeneratedField::Status),
8891 "version" => Ok(GeneratedField::Version),
8892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8893 }
8894 }
8895 }
8896 deserializer.deserialize_identifier(GeneratedVisitor)
8897 }
8898 }
8899 struct GeneratedVisitor;
8900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8901 type Value = DropMaterializedViewResponse;
8902
8903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8904 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
8905 }
8906
8907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
8908 where
8909 V: serde::de::MapAccess<'de>,
8910 {
8911 let mut status__ = None;
8912 let mut version__ = None;
8913 while let Some(k) = map_.next_key()? {
8914 match k {
8915 GeneratedField::Status => {
8916 if status__.is_some() {
8917 return Err(serde::de::Error::duplicate_field("status"));
8918 }
8919 status__ = map_.next_value()?;
8920 }
8921 GeneratedField::Version => {
8922 if version__.is_some() {
8923 return Err(serde::de::Error::duplicate_field("version"));
8924 }
8925 version__ = map_.next_value()?;
8926 }
8927 }
8928 }
8929 Ok(DropMaterializedViewResponse {
8930 status: status__,
8931 version: version__,
8932 })
8933 }
8934 }
8935 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
8936 }
8937}
8938impl serde::Serialize for DropSchemaRequest {
8939 #[allow(deprecated)]
8940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8941 where
8942 S: serde::Serializer,
8943 {
8944 use serde::ser::SerializeStruct;
8945 let mut len = 0;
8946 if self.schema_id != 0 {
8947 len += 1;
8948 }
8949 if self.cascade {
8950 len += 1;
8951 }
8952 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
8953 if self.schema_id != 0 {
8954 struct_ser.serialize_field("schemaId", &self.schema_id)?;
8955 }
8956 if self.cascade {
8957 struct_ser.serialize_field("cascade", &self.cascade)?;
8958 }
8959 struct_ser.end()
8960 }
8961}
8962impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
8963 #[allow(deprecated)]
8964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8965 where
8966 D: serde::Deserializer<'de>,
8967 {
8968 const FIELDS: &[&str] = &[
8969 "schema_id",
8970 "schemaId",
8971 "cascade",
8972 ];
8973
8974 #[allow(clippy::enum_variant_names)]
8975 enum GeneratedField {
8976 SchemaId,
8977 Cascade,
8978 }
8979 impl<'de> serde::Deserialize<'de> for GeneratedField {
8980 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8981 where
8982 D: serde::Deserializer<'de>,
8983 {
8984 struct GeneratedVisitor;
8985
8986 impl serde::de::Visitor<'_> for GeneratedVisitor {
8987 type Value = GeneratedField;
8988
8989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8990 write!(formatter, "expected one of: {:?}", &FIELDS)
8991 }
8992
8993 #[allow(unused_variables)]
8994 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8995 where
8996 E: serde::de::Error,
8997 {
8998 match value {
8999 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
9000 "cascade" => Ok(GeneratedField::Cascade),
9001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9002 }
9003 }
9004 }
9005 deserializer.deserialize_identifier(GeneratedVisitor)
9006 }
9007 }
9008 struct GeneratedVisitor;
9009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9010 type Value = DropSchemaRequest;
9011
9012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9013 formatter.write_str("struct ddl_service.DropSchemaRequest")
9014 }
9015
9016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
9017 where
9018 V: serde::de::MapAccess<'de>,
9019 {
9020 let mut schema_id__ = None;
9021 let mut cascade__ = None;
9022 while let Some(k) = map_.next_key()? {
9023 match k {
9024 GeneratedField::SchemaId => {
9025 if schema_id__.is_some() {
9026 return Err(serde::de::Error::duplicate_field("schemaId"));
9027 }
9028 schema_id__ =
9029 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9030 ;
9031 }
9032 GeneratedField::Cascade => {
9033 if cascade__.is_some() {
9034 return Err(serde::de::Error::duplicate_field("cascade"));
9035 }
9036 cascade__ = Some(map_.next_value()?);
9037 }
9038 }
9039 }
9040 Ok(DropSchemaRequest {
9041 schema_id: schema_id__.unwrap_or_default(),
9042 cascade: cascade__.unwrap_or_default(),
9043 })
9044 }
9045 }
9046 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
9047 }
9048}
9049impl serde::Serialize for DropSchemaResponse {
9050 #[allow(deprecated)]
9051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9052 where
9053 S: serde::Serializer,
9054 {
9055 use serde::ser::SerializeStruct;
9056 let mut len = 0;
9057 if self.status.is_some() {
9058 len += 1;
9059 }
9060 if self.version.is_some() {
9061 len += 1;
9062 }
9063 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
9064 if let Some(v) = self.status.as_ref() {
9065 struct_ser.serialize_field("status", v)?;
9066 }
9067 if let Some(v) = self.version.as_ref() {
9068 struct_ser.serialize_field("version", v)?;
9069 }
9070 struct_ser.end()
9071 }
9072}
9073impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
9074 #[allow(deprecated)]
9075 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9076 where
9077 D: serde::Deserializer<'de>,
9078 {
9079 const FIELDS: &[&str] = &[
9080 "status",
9081 "version",
9082 ];
9083
9084 #[allow(clippy::enum_variant_names)]
9085 enum GeneratedField {
9086 Status,
9087 Version,
9088 }
9089 impl<'de> serde::Deserialize<'de> for GeneratedField {
9090 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9091 where
9092 D: serde::Deserializer<'de>,
9093 {
9094 struct GeneratedVisitor;
9095
9096 impl serde::de::Visitor<'_> for GeneratedVisitor {
9097 type Value = GeneratedField;
9098
9099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9100 write!(formatter, "expected one of: {:?}", &FIELDS)
9101 }
9102
9103 #[allow(unused_variables)]
9104 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9105 where
9106 E: serde::de::Error,
9107 {
9108 match value {
9109 "status" => Ok(GeneratedField::Status),
9110 "version" => Ok(GeneratedField::Version),
9111 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9112 }
9113 }
9114 }
9115 deserializer.deserialize_identifier(GeneratedVisitor)
9116 }
9117 }
9118 struct GeneratedVisitor;
9119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9120 type Value = DropSchemaResponse;
9121
9122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9123 formatter.write_str("struct ddl_service.DropSchemaResponse")
9124 }
9125
9126 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
9127 where
9128 V: serde::de::MapAccess<'de>,
9129 {
9130 let mut status__ = None;
9131 let mut version__ = None;
9132 while let Some(k) = map_.next_key()? {
9133 match k {
9134 GeneratedField::Status => {
9135 if status__.is_some() {
9136 return Err(serde::de::Error::duplicate_field("status"));
9137 }
9138 status__ = map_.next_value()?;
9139 }
9140 GeneratedField::Version => {
9141 if version__.is_some() {
9142 return Err(serde::de::Error::duplicate_field("version"));
9143 }
9144 version__ = map_.next_value()?;
9145 }
9146 }
9147 }
9148 Ok(DropSchemaResponse {
9149 status: status__,
9150 version: version__,
9151 })
9152 }
9153 }
9154 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
9155 }
9156}
9157impl serde::Serialize for DropSecretRequest {
9158 #[allow(deprecated)]
9159 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9160 where
9161 S: serde::Serializer,
9162 {
9163 use serde::ser::SerializeStruct;
9164 let mut len = 0;
9165 if self.secret_id != 0 {
9166 len += 1;
9167 }
9168 if self.cascade {
9169 len += 1;
9170 }
9171 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
9172 if self.secret_id != 0 {
9173 struct_ser.serialize_field("secretId", &self.secret_id)?;
9174 }
9175 if self.cascade {
9176 struct_ser.serialize_field("cascade", &self.cascade)?;
9177 }
9178 struct_ser.end()
9179 }
9180}
9181impl<'de> serde::Deserialize<'de> for DropSecretRequest {
9182 #[allow(deprecated)]
9183 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9184 where
9185 D: serde::Deserializer<'de>,
9186 {
9187 const FIELDS: &[&str] = &[
9188 "secret_id",
9189 "secretId",
9190 "cascade",
9191 ];
9192
9193 #[allow(clippy::enum_variant_names)]
9194 enum GeneratedField {
9195 SecretId,
9196 Cascade,
9197 }
9198 impl<'de> serde::Deserialize<'de> for GeneratedField {
9199 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9200 where
9201 D: serde::Deserializer<'de>,
9202 {
9203 struct GeneratedVisitor;
9204
9205 impl serde::de::Visitor<'_> for GeneratedVisitor {
9206 type Value = GeneratedField;
9207
9208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9209 write!(formatter, "expected one of: {:?}", &FIELDS)
9210 }
9211
9212 #[allow(unused_variables)]
9213 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9214 where
9215 E: serde::de::Error,
9216 {
9217 match value {
9218 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
9219 "cascade" => Ok(GeneratedField::Cascade),
9220 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9221 }
9222 }
9223 }
9224 deserializer.deserialize_identifier(GeneratedVisitor)
9225 }
9226 }
9227 struct GeneratedVisitor;
9228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9229 type Value = DropSecretRequest;
9230
9231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9232 formatter.write_str("struct ddl_service.DropSecretRequest")
9233 }
9234
9235 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
9236 where
9237 V: serde::de::MapAccess<'de>,
9238 {
9239 let mut secret_id__ = None;
9240 let mut cascade__ = None;
9241 while let Some(k) = map_.next_key()? {
9242 match k {
9243 GeneratedField::SecretId => {
9244 if secret_id__.is_some() {
9245 return Err(serde::de::Error::duplicate_field("secretId"));
9246 }
9247 secret_id__ =
9248 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9249 ;
9250 }
9251 GeneratedField::Cascade => {
9252 if cascade__.is_some() {
9253 return Err(serde::de::Error::duplicate_field("cascade"));
9254 }
9255 cascade__ = Some(map_.next_value()?);
9256 }
9257 }
9258 }
9259 Ok(DropSecretRequest {
9260 secret_id: secret_id__.unwrap_or_default(),
9261 cascade: cascade__.unwrap_or_default(),
9262 })
9263 }
9264 }
9265 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
9266 }
9267}
9268impl serde::Serialize for DropSecretResponse {
9269 #[allow(deprecated)]
9270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9271 where
9272 S: serde::Serializer,
9273 {
9274 use serde::ser::SerializeStruct;
9275 let mut len = 0;
9276 if self.version.is_some() {
9277 len += 1;
9278 }
9279 if self.status.is_some() {
9280 len += 1;
9281 }
9282 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
9283 if let Some(v) = self.version.as_ref() {
9284 struct_ser.serialize_field("version", v)?;
9285 }
9286 if let Some(v) = self.status.as_ref() {
9287 struct_ser.serialize_field("status", v)?;
9288 }
9289 struct_ser.end()
9290 }
9291}
9292impl<'de> serde::Deserialize<'de> for DropSecretResponse {
9293 #[allow(deprecated)]
9294 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9295 where
9296 D: serde::Deserializer<'de>,
9297 {
9298 const FIELDS: &[&str] = &[
9299 "version",
9300 "status",
9301 ];
9302
9303 #[allow(clippy::enum_variant_names)]
9304 enum GeneratedField {
9305 Version,
9306 Status,
9307 }
9308 impl<'de> serde::Deserialize<'de> for GeneratedField {
9309 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9310 where
9311 D: serde::Deserializer<'de>,
9312 {
9313 struct GeneratedVisitor;
9314
9315 impl serde::de::Visitor<'_> for GeneratedVisitor {
9316 type Value = GeneratedField;
9317
9318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9319 write!(formatter, "expected one of: {:?}", &FIELDS)
9320 }
9321
9322 #[allow(unused_variables)]
9323 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9324 where
9325 E: serde::de::Error,
9326 {
9327 match value {
9328 "version" => Ok(GeneratedField::Version),
9329 "status" => Ok(GeneratedField::Status),
9330 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9331 }
9332 }
9333 }
9334 deserializer.deserialize_identifier(GeneratedVisitor)
9335 }
9336 }
9337 struct GeneratedVisitor;
9338 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9339 type Value = DropSecretResponse;
9340
9341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9342 formatter.write_str("struct ddl_service.DropSecretResponse")
9343 }
9344
9345 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
9346 where
9347 V: serde::de::MapAccess<'de>,
9348 {
9349 let mut version__ = None;
9350 let mut status__ = None;
9351 while let Some(k) = map_.next_key()? {
9352 match k {
9353 GeneratedField::Version => {
9354 if version__.is_some() {
9355 return Err(serde::de::Error::duplicate_field("version"));
9356 }
9357 version__ = map_.next_value()?;
9358 }
9359 GeneratedField::Status => {
9360 if status__.is_some() {
9361 return Err(serde::de::Error::duplicate_field("status"));
9362 }
9363 status__ = map_.next_value()?;
9364 }
9365 }
9366 }
9367 Ok(DropSecretResponse {
9368 version: version__,
9369 status: status__,
9370 })
9371 }
9372 }
9373 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
9374 }
9375}
9376impl serde::Serialize for DropSinkRequest {
9377 #[allow(deprecated)]
9378 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9379 where
9380 S: serde::Serializer,
9381 {
9382 use serde::ser::SerializeStruct;
9383 let mut len = 0;
9384 if self.sink_id != 0 {
9385 len += 1;
9386 }
9387 if self.cascade {
9388 len += 1;
9389 }
9390 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
9391 if self.sink_id != 0 {
9392 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9393 }
9394 if self.cascade {
9395 struct_ser.serialize_field("cascade", &self.cascade)?;
9396 }
9397 struct_ser.end()
9398 }
9399}
9400impl<'de> serde::Deserialize<'de> for DropSinkRequest {
9401 #[allow(deprecated)]
9402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9403 where
9404 D: serde::Deserializer<'de>,
9405 {
9406 const FIELDS: &[&str] = &[
9407 "sink_id",
9408 "sinkId",
9409 "cascade",
9410 ];
9411
9412 #[allow(clippy::enum_variant_names)]
9413 enum GeneratedField {
9414 SinkId,
9415 Cascade,
9416 }
9417 impl<'de> serde::Deserialize<'de> for GeneratedField {
9418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9419 where
9420 D: serde::Deserializer<'de>,
9421 {
9422 struct GeneratedVisitor;
9423
9424 impl serde::de::Visitor<'_> for GeneratedVisitor {
9425 type Value = GeneratedField;
9426
9427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9428 write!(formatter, "expected one of: {:?}", &FIELDS)
9429 }
9430
9431 #[allow(unused_variables)]
9432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9433 where
9434 E: serde::de::Error,
9435 {
9436 match value {
9437 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9438 "cascade" => Ok(GeneratedField::Cascade),
9439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9440 }
9441 }
9442 }
9443 deserializer.deserialize_identifier(GeneratedVisitor)
9444 }
9445 }
9446 struct GeneratedVisitor;
9447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9448 type Value = DropSinkRequest;
9449
9450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9451 formatter.write_str("struct ddl_service.DropSinkRequest")
9452 }
9453
9454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
9455 where
9456 V: serde::de::MapAccess<'de>,
9457 {
9458 let mut sink_id__ = None;
9459 let mut cascade__ = None;
9460 while let Some(k) = map_.next_key()? {
9461 match k {
9462 GeneratedField::SinkId => {
9463 if sink_id__.is_some() {
9464 return Err(serde::de::Error::duplicate_field("sinkId"));
9465 }
9466 sink_id__ =
9467 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9468 ;
9469 }
9470 GeneratedField::Cascade => {
9471 if cascade__.is_some() {
9472 return Err(serde::de::Error::duplicate_field("cascade"));
9473 }
9474 cascade__ = Some(map_.next_value()?);
9475 }
9476 }
9477 }
9478 Ok(DropSinkRequest {
9479 sink_id: sink_id__.unwrap_or_default(),
9480 cascade: cascade__.unwrap_or_default(),
9481 })
9482 }
9483 }
9484 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
9485 }
9486}
9487impl serde::Serialize for DropSinkResponse {
9488 #[allow(deprecated)]
9489 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9490 where
9491 S: serde::Serializer,
9492 {
9493 use serde::ser::SerializeStruct;
9494 let mut len = 0;
9495 if self.status.is_some() {
9496 len += 1;
9497 }
9498 if self.version.is_some() {
9499 len += 1;
9500 }
9501 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
9502 if let Some(v) = self.status.as_ref() {
9503 struct_ser.serialize_field("status", v)?;
9504 }
9505 if let Some(v) = self.version.as_ref() {
9506 struct_ser.serialize_field("version", v)?;
9507 }
9508 struct_ser.end()
9509 }
9510}
9511impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9512 #[allow(deprecated)]
9513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9514 where
9515 D: serde::Deserializer<'de>,
9516 {
9517 const FIELDS: &[&str] = &[
9518 "status",
9519 "version",
9520 ];
9521
9522 #[allow(clippy::enum_variant_names)]
9523 enum GeneratedField {
9524 Status,
9525 Version,
9526 }
9527 impl<'de> serde::Deserialize<'de> for GeneratedField {
9528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9529 where
9530 D: serde::Deserializer<'de>,
9531 {
9532 struct GeneratedVisitor;
9533
9534 impl serde::de::Visitor<'_> for GeneratedVisitor {
9535 type Value = GeneratedField;
9536
9537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9538 write!(formatter, "expected one of: {:?}", &FIELDS)
9539 }
9540
9541 #[allow(unused_variables)]
9542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9543 where
9544 E: serde::de::Error,
9545 {
9546 match value {
9547 "status" => Ok(GeneratedField::Status),
9548 "version" => Ok(GeneratedField::Version),
9549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9550 }
9551 }
9552 }
9553 deserializer.deserialize_identifier(GeneratedVisitor)
9554 }
9555 }
9556 struct GeneratedVisitor;
9557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9558 type Value = DropSinkResponse;
9559
9560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9561 formatter.write_str("struct ddl_service.DropSinkResponse")
9562 }
9563
9564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9565 where
9566 V: serde::de::MapAccess<'de>,
9567 {
9568 let mut status__ = None;
9569 let mut version__ = None;
9570 while let Some(k) = map_.next_key()? {
9571 match k {
9572 GeneratedField::Status => {
9573 if status__.is_some() {
9574 return Err(serde::de::Error::duplicate_field("status"));
9575 }
9576 status__ = map_.next_value()?;
9577 }
9578 GeneratedField::Version => {
9579 if version__.is_some() {
9580 return Err(serde::de::Error::duplicate_field("version"));
9581 }
9582 version__ = map_.next_value()?;
9583 }
9584 }
9585 }
9586 Ok(DropSinkResponse {
9587 status: status__,
9588 version: version__,
9589 })
9590 }
9591 }
9592 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9593 }
9594}
9595impl serde::Serialize for DropSourceRequest {
9596 #[allow(deprecated)]
9597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9598 where
9599 S: serde::Serializer,
9600 {
9601 use serde::ser::SerializeStruct;
9602 let mut len = 0;
9603 if self.source_id != 0 {
9604 len += 1;
9605 }
9606 if self.cascade {
9607 len += 1;
9608 }
9609 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9610 if self.source_id != 0 {
9611 struct_ser.serialize_field("sourceId", &self.source_id)?;
9612 }
9613 if self.cascade {
9614 struct_ser.serialize_field("cascade", &self.cascade)?;
9615 }
9616 struct_ser.end()
9617 }
9618}
9619impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9620 #[allow(deprecated)]
9621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622 where
9623 D: serde::Deserializer<'de>,
9624 {
9625 const FIELDS: &[&str] = &[
9626 "source_id",
9627 "sourceId",
9628 "cascade",
9629 ];
9630
9631 #[allow(clippy::enum_variant_names)]
9632 enum GeneratedField {
9633 SourceId,
9634 Cascade,
9635 }
9636 impl<'de> serde::Deserialize<'de> for GeneratedField {
9637 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9638 where
9639 D: serde::Deserializer<'de>,
9640 {
9641 struct GeneratedVisitor;
9642
9643 impl serde::de::Visitor<'_> for GeneratedVisitor {
9644 type Value = GeneratedField;
9645
9646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9647 write!(formatter, "expected one of: {:?}", &FIELDS)
9648 }
9649
9650 #[allow(unused_variables)]
9651 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9652 where
9653 E: serde::de::Error,
9654 {
9655 match value {
9656 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9657 "cascade" => Ok(GeneratedField::Cascade),
9658 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9659 }
9660 }
9661 }
9662 deserializer.deserialize_identifier(GeneratedVisitor)
9663 }
9664 }
9665 struct GeneratedVisitor;
9666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9667 type Value = DropSourceRequest;
9668
9669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9670 formatter.write_str("struct ddl_service.DropSourceRequest")
9671 }
9672
9673 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9674 where
9675 V: serde::de::MapAccess<'de>,
9676 {
9677 let mut source_id__ = None;
9678 let mut cascade__ = None;
9679 while let Some(k) = map_.next_key()? {
9680 match k {
9681 GeneratedField::SourceId => {
9682 if source_id__.is_some() {
9683 return Err(serde::de::Error::duplicate_field("sourceId"));
9684 }
9685 source_id__ =
9686 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9687 ;
9688 }
9689 GeneratedField::Cascade => {
9690 if cascade__.is_some() {
9691 return Err(serde::de::Error::duplicate_field("cascade"));
9692 }
9693 cascade__ = Some(map_.next_value()?);
9694 }
9695 }
9696 }
9697 Ok(DropSourceRequest {
9698 source_id: source_id__.unwrap_or_default(),
9699 cascade: cascade__.unwrap_or_default(),
9700 })
9701 }
9702 }
9703 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
9704 }
9705}
9706impl serde::Serialize for DropSourceResponse {
9707 #[allow(deprecated)]
9708 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9709 where
9710 S: serde::Serializer,
9711 {
9712 use serde::ser::SerializeStruct;
9713 let mut len = 0;
9714 if self.status.is_some() {
9715 len += 1;
9716 }
9717 if self.version.is_some() {
9718 len += 1;
9719 }
9720 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
9721 if let Some(v) = self.status.as_ref() {
9722 struct_ser.serialize_field("status", v)?;
9723 }
9724 if let Some(v) = self.version.as_ref() {
9725 struct_ser.serialize_field("version", v)?;
9726 }
9727 struct_ser.end()
9728 }
9729}
9730impl<'de> serde::Deserialize<'de> for DropSourceResponse {
9731 #[allow(deprecated)]
9732 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9733 where
9734 D: serde::Deserializer<'de>,
9735 {
9736 const FIELDS: &[&str] = &[
9737 "status",
9738 "version",
9739 ];
9740
9741 #[allow(clippy::enum_variant_names)]
9742 enum GeneratedField {
9743 Status,
9744 Version,
9745 }
9746 impl<'de> serde::Deserialize<'de> for GeneratedField {
9747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9748 where
9749 D: serde::Deserializer<'de>,
9750 {
9751 struct GeneratedVisitor;
9752
9753 impl serde::de::Visitor<'_> for GeneratedVisitor {
9754 type Value = GeneratedField;
9755
9756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9757 write!(formatter, "expected one of: {:?}", &FIELDS)
9758 }
9759
9760 #[allow(unused_variables)]
9761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9762 where
9763 E: serde::de::Error,
9764 {
9765 match value {
9766 "status" => Ok(GeneratedField::Status),
9767 "version" => Ok(GeneratedField::Version),
9768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9769 }
9770 }
9771 }
9772 deserializer.deserialize_identifier(GeneratedVisitor)
9773 }
9774 }
9775 struct GeneratedVisitor;
9776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9777 type Value = DropSourceResponse;
9778
9779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9780 formatter.write_str("struct ddl_service.DropSourceResponse")
9781 }
9782
9783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9784 where
9785 V: serde::de::MapAccess<'de>,
9786 {
9787 let mut status__ = None;
9788 let mut version__ = None;
9789 while let Some(k) = map_.next_key()? {
9790 match k {
9791 GeneratedField::Status => {
9792 if status__.is_some() {
9793 return Err(serde::de::Error::duplicate_field("status"));
9794 }
9795 status__ = map_.next_value()?;
9796 }
9797 GeneratedField::Version => {
9798 if version__.is_some() {
9799 return Err(serde::de::Error::duplicate_field("version"));
9800 }
9801 version__ = map_.next_value()?;
9802 }
9803 }
9804 }
9805 Ok(DropSourceResponse {
9806 status: status__,
9807 version: version__,
9808 })
9809 }
9810 }
9811 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9812 }
9813}
9814impl serde::Serialize for DropSubscriptionRequest {
9815 #[allow(deprecated)]
9816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9817 where
9818 S: serde::Serializer,
9819 {
9820 use serde::ser::SerializeStruct;
9821 let mut len = 0;
9822 if self.subscription_id != 0 {
9823 len += 1;
9824 }
9825 if self.cascade {
9826 len += 1;
9827 }
9828 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9829 if self.subscription_id != 0 {
9830 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9831 }
9832 if self.cascade {
9833 struct_ser.serialize_field("cascade", &self.cascade)?;
9834 }
9835 struct_ser.end()
9836 }
9837}
9838impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9839 #[allow(deprecated)]
9840 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9841 where
9842 D: serde::Deserializer<'de>,
9843 {
9844 const FIELDS: &[&str] = &[
9845 "subscription_id",
9846 "subscriptionId",
9847 "cascade",
9848 ];
9849
9850 #[allow(clippy::enum_variant_names)]
9851 enum GeneratedField {
9852 SubscriptionId,
9853 Cascade,
9854 }
9855 impl<'de> serde::Deserialize<'de> for GeneratedField {
9856 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9857 where
9858 D: serde::Deserializer<'de>,
9859 {
9860 struct GeneratedVisitor;
9861
9862 impl serde::de::Visitor<'_> for GeneratedVisitor {
9863 type Value = GeneratedField;
9864
9865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9866 write!(formatter, "expected one of: {:?}", &FIELDS)
9867 }
9868
9869 #[allow(unused_variables)]
9870 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9871 where
9872 E: serde::de::Error,
9873 {
9874 match value {
9875 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9876 "cascade" => Ok(GeneratedField::Cascade),
9877 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9878 }
9879 }
9880 }
9881 deserializer.deserialize_identifier(GeneratedVisitor)
9882 }
9883 }
9884 struct GeneratedVisitor;
9885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9886 type Value = DropSubscriptionRequest;
9887
9888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9889 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9890 }
9891
9892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9893 where
9894 V: serde::de::MapAccess<'de>,
9895 {
9896 let mut subscription_id__ = None;
9897 let mut cascade__ = None;
9898 while let Some(k) = map_.next_key()? {
9899 match k {
9900 GeneratedField::SubscriptionId => {
9901 if subscription_id__.is_some() {
9902 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9903 }
9904 subscription_id__ =
9905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9906 ;
9907 }
9908 GeneratedField::Cascade => {
9909 if cascade__.is_some() {
9910 return Err(serde::de::Error::duplicate_field("cascade"));
9911 }
9912 cascade__ = Some(map_.next_value()?);
9913 }
9914 }
9915 }
9916 Ok(DropSubscriptionRequest {
9917 subscription_id: subscription_id__.unwrap_or_default(),
9918 cascade: cascade__.unwrap_or_default(),
9919 })
9920 }
9921 }
9922 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9923 }
9924}
9925impl serde::Serialize for DropSubscriptionResponse {
9926 #[allow(deprecated)]
9927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9928 where
9929 S: serde::Serializer,
9930 {
9931 use serde::ser::SerializeStruct;
9932 let mut len = 0;
9933 if self.status.is_some() {
9934 len += 1;
9935 }
9936 if self.version.is_some() {
9937 len += 1;
9938 }
9939 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9940 if let Some(v) = self.status.as_ref() {
9941 struct_ser.serialize_field("status", v)?;
9942 }
9943 if let Some(v) = self.version.as_ref() {
9944 struct_ser.serialize_field("version", v)?;
9945 }
9946 struct_ser.end()
9947 }
9948}
9949impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9950 #[allow(deprecated)]
9951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9952 where
9953 D: serde::Deserializer<'de>,
9954 {
9955 const FIELDS: &[&str] = &[
9956 "status",
9957 "version",
9958 ];
9959
9960 #[allow(clippy::enum_variant_names)]
9961 enum GeneratedField {
9962 Status,
9963 Version,
9964 }
9965 impl<'de> serde::Deserialize<'de> for GeneratedField {
9966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9967 where
9968 D: serde::Deserializer<'de>,
9969 {
9970 struct GeneratedVisitor;
9971
9972 impl serde::de::Visitor<'_> for GeneratedVisitor {
9973 type Value = GeneratedField;
9974
9975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9976 write!(formatter, "expected one of: {:?}", &FIELDS)
9977 }
9978
9979 #[allow(unused_variables)]
9980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9981 where
9982 E: serde::de::Error,
9983 {
9984 match value {
9985 "status" => Ok(GeneratedField::Status),
9986 "version" => Ok(GeneratedField::Version),
9987 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9988 }
9989 }
9990 }
9991 deserializer.deserialize_identifier(GeneratedVisitor)
9992 }
9993 }
9994 struct GeneratedVisitor;
9995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9996 type Value = DropSubscriptionResponse;
9997
9998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9999 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
10000 }
10001
10002 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
10003 where
10004 V: serde::de::MapAccess<'de>,
10005 {
10006 let mut status__ = None;
10007 let mut version__ = None;
10008 while let Some(k) = map_.next_key()? {
10009 match k {
10010 GeneratedField::Status => {
10011 if status__.is_some() {
10012 return Err(serde::de::Error::duplicate_field("status"));
10013 }
10014 status__ = map_.next_value()?;
10015 }
10016 GeneratedField::Version => {
10017 if version__.is_some() {
10018 return Err(serde::de::Error::duplicate_field("version"));
10019 }
10020 version__ = map_.next_value()?;
10021 }
10022 }
10023 }
10024 Ok(DropSubscriptionResponse {
10025 status: status__,
10026 version: version__,
10027 })
10028 }
10029 }
10030 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
10031 }
10032}
10033impl serde::Serialize for DropTableRequest {
10034 #[allow(deprecated)]
10035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10036 where
10037 S: serde::Serializer,
10038 {
10039 use serde::ser::SerializeStruct;
10040 let mut len = 0;
10041 if self.table_id != 0 {
10042 len += 1;
10043 }
10044 if self.cascade {
10045 len += 1;
10046 }
10047 if self.source_id.is_some() {
10048 len += 1;
10049 }
10050 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
10051 if self.table_id != 0 {
10052 struct_ser.serialize_field("tableId", &self.table_id)?;
10053 }
10054 if self.cascade {
10055 struct_ser.serialize_field("cascade", &self.cascade)?;
10056 }
10057 if let Some(v) = self.source_id.as_ref() {
10058 match v {
10059 drop_table_request::SourceId::Id(v) => {
10060 struct_ser.serialize_field("id", v)?;
10061 }
10062 }
10063 }
10064 struct_ser.end()
10065 }
10066}
10067impl<'de> serde::Deserialize<'de> for DropTableRequest {
10068 #[allow(deprecated)]
10069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10070 where
10071 D: serde::Deserializer<'de>,
10072 {
10073 const FIELDS: &[&str] = &[
10074 "table_id",
10075 "tableId",
10076 "cascade",
10077 "id",
10078 ];
10079
10080 #[allow(clippy::enum_variant_names)]
10081 enum GeneratedField {
10082 TableId,
10083 Cascade,
10084 Id,
10085 }
10086 impl<'de> serde::Deserialize<'de> for GeneratedField {
10087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10088 where
10089 D: serde::Deserializer<'de>,
10090 {
10091 struct GeneratedVisitor;
10092
10093 impl serde::de::Visitor<'_> for GeneratedVisitor {
10094 type Value = GeneratedField;
10095
10096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10097 write!(formatter, "expected one of: {:?}", &FIELDS)
10098 }
10099
10100 #[allow(unused_variables)]
10101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10102 where
10103 E: serde::de::Error,
10104 {
10105 match value {
10106 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10107 "cascade" => Ok(GeneratedField::Cascade),
10108 "id" => Ok(GeneratedField::Id),
10109 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10110 }
10111 }
10112 }
10113 deserializer.deserialize_identifier(GeneratedVisitor)
10114 }
10115 }
10116 struct GeneratedVisitor;
10117 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10118 type Value = DropTableRequest;
10119
10120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10121 formatter.write_str("struct ddl_service.DropTableRequest")
10122 }
10123
10124 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
10125 where
10126 V: serde::de::MapAccess<'de>,
10127 {
10128 let mut table_id__ = None;
10129 let mut cascade__ = None;
10130 let mut source_id__ = None;
10131 while let Some(k) = map_.next_key()? {
10132 match k {
10133 GeneratedField::TableId => {
10134 if table_id__.is_some() {
10135 return Err(serde::de::Error::duplicate_field("tableId"));
10136 }
10137 table_id__ =
10138 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10139 ;
10140 }
10141 GeneratedField::Cascade => {
10142 if cascade__.is_some() {
10143 return Err(serde::de::Error::duplicate_field("cascade"));
10144 }
10145 cascade__ = Some(map_.next_value()?);
10146 }
10147 GeneratedField::Id => {
10148 if source_id__.is_some() {
10149 return Err(serde::de::Error::duplicate_field("id"));
10150 }
10151 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
10152 }
10153 }
10154 }
10155 Ok(DropTableRequest {
10156 table_id: table_id__.unwrap_or_default(),
10157 cascade: cascade__.unwrap_or_default(),
10158 source_id: source_id__,
10159 })
10160 }
10161 }
10162 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
10163 }
10164}
10165impl serde::Serialize for DropTableResponse {
10166 #[allow(deprecated)]
10167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10168 where
10169 S: serde::Serializer,
10170 {
10171 use serde::ser::SerializeStruct;
10172 let mut len = 0;
10173 if self.status.is_some() {
10174 len += 1;
10175 }
10176 if self.version.is_some() {
10177 len += 1;
10178 }
10179 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
10180 if let Some(v) = self.status.as_ref() {
10181 struct_ser.serialize_field("status", v)?;
10182 }
10183 if let Some(v) = self.version.as_ref() {
10184 struct_ser.serialize_field("version", v)?;
10185 }
10186 struct_ser.end()
10187 }
10188}
10189impl<'de> serde::Deserialize<'de> for DropTableResponse {
10190 #[allow(deprecated)]
10191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10192 where
10193 D: serde::Deserializer<'de>,
10194 {
10195 const FIELDS: &[&str] = &[
10196 "status",
10197 "version",
10198 ];
10199
10200 #[allow(clippy::enum_variant_names)]
10201 enum GeneratedField {
10202 Status,
10203 Version,
10204 }
10205 impl<'de> serde::Deserialize<'de> for GeneratedField {
10206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10207 where
10208 D: serde::Deserializer<'de>,
10209 {
10210 struct GeneratedVisitor;
10211
10212 impl serde::de::Visitor<'_> for GeneratedVisitor {
10213 type Value = GeneratedField;
10214
10215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10216 write!(formatter, "expected one of: {:?}", &FIELDS)
10217 }
10218
10219 #[allow(unused_variables)]
10220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10221 where
10222 E: serde::de::Error,
10223 {
10224 match value {
10225 "status" => Ok(GeneratedField::Status),
10226 "version" => Ok(GeneratedField::Version),
10227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10228 }
10229 }
10230 }
10231 deserializer.deserialize_identifier(GeneratedVisitor)
10232 }
10233 }
10234 struct GeneratedVisitor;
10235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10236 type Value = DropTableResponse;
10237
10238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10239 formatter.write_str("struct ddl_service.DropTableResponse")
10240 }
10241
10242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
10243 where
10244 V: serde::de::MapAccess<'de>,
10245 {
10246 let mut status__ = None;
10247 let mut version__ = None;
10248 while let Some(k) = map_.next_key()? {
10249 match k {
10250 GeneratedField::Status => {
10251 if status__.is_some() {
10252 return Err(serde::de::Error::duplicate_field("status"));
10253 }
10254 status__ = map_.next_value()?;
10255 }
10256 GeneratedField::Version => {
10257 if version__.is_some() {
10258 return Err(serde::de::Error::duplicate_field("version"));
10259 }
10260 version__ = map_.next_value()?;
10261 }
10262 }
10263 }
10264 Ok(DropTableResponse {
10265 status: status__,
10266 version: version__,
10267 })
10268 }
10269 }
10270 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
10271 }
10272}
10273impl serde::Serialize for DropViewRequest {
10274 #[allow(deprecated)]
10275 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10276 where
10277 S: serde::Serializer,
10278 {
10279 use serde::ser::SerializeStruct;
10280 let mut len = 0;
10281 if self.view_id != 0 {
10282 len += 1;
10283 }
10284 if self.cascade {
10285 len += 1;
10286 }
10287 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
10288 if self.view_id != 0 {
10289 struct_ser.serialize_field("viewId", &self.view_id)?;
10290 }
10291 if self.cascade {
10292 struct_ser.serialize_field("cascade", &self.cascade)?;
10293 }
10294 struct_ser.end()
10295 }
10296}
10297impl<'de> serde::Deserialize<'de> for DropViewRequest {
10298 #[allow(deprecated)]
10299 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10300 where
10301 D: serde::Deserializer<'de>,
10302 {
10303 const FIELDS: &[&str] = &[
10304 "view_id",
10305 "viewId",
10306 "cascade",
10307 ];
10308
10309 #[allow(clippy::enum_variant_names)]
10310 enum GeneratedField {
10311 ViewId,
10312 Cascade,
10313 }
10314 impl<'de> serde::Deserialize<'de> for GeneratedField {
10315 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10316 where
10317 D: serde::Deserializer<'de>,
10318 {
10319 struct GeneratedVisitor;
10320
10321 impl serde::de::Visitor<'_> for GeneratedVisitor {
10322 type Value = GeneratedField;
10323
10324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10325 write!(formatter, "expected one of: {:?}", &FIELDS)
10326 }
10327
10328 #[allow(unused_variables)]
10329 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10330 where
10331 E: serde::de::Error,
10332 {
10333 match value {
10334 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
10335 "cascade" => Ok(GeneratedField::Cascade),
10336 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10337 }
10338 }
10339 }
10340 deserializer.deserialize_identifier(GeneratedVisitor)
10341 }
10342 }
10343 struct GeneratedVisitor;
10344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10345 type Value = DropViewRequest;
10346
10347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10348 formatter.write_str("struct ddl_service.DropViewRequest")
10349 }
10350
10351 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
10352 where
10353 V: serde::de::MapAccess<'de>,
10354 {
10355 let mut view_id__ = None;
10356 let mut cascade__ = None;
10357 while let Some(k) = map_.next_key()? {
10358 match k {
10359 GeneratedField::ViewId => {
10360 if view_id__.is_some() {
10361 return Err(serde::de::Error::duplicate_field("viewId"));
10362 }
10363 view_id__ =
10364 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10365 ;
10366 }
10367 GeneratedField::Cascade => {
10368 if cascade__.is_some() {
10369 return Err(serde::de::Error::duplicate_field("cascade"));
10370 }
10371 cascade__ = Some(map_.next_value()?);
10372 }
10373 }
10374 }
10375 Ok(DropViewRequest {
10376 view_id: view_id__.unwrap_or_default(),
10377 cascade: cascade__.unwrap_or_default(),
10378 })
10379 }
10380 }
10381 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
10382 }
10383}
10384impl serde::Serialize for DropViewResponse {
10385 #[allow(deprecated)]
10386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10387 where
10388 S: serde::Serializer,
10389 {
10390 use serde::ser::SerializeStruct;
10391 let mut len = 0;
10392 if self.status.is_some() {
10393 len += 1;
10394 }
10395 if self.version.is_some() {
10396 len += 1;
10397 }
10398 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
10399 if let Some(v) = self.status.as_ref() {
10400 struct_ser.serialize_field("status", v)?;
10401 }
10402 if let Some(v) = self.version.as_ref() {
10403 struct_ser.serialize_field("version", v)?;
10404 }
10405 struct_ser.end()
10406 }
10407}
10408impl<'de> serde::Deserialize<'de> for DropViewResponse {
10409 #[allow(deprecated)]
10410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10411 where
10412 D: serde::Deserializer<'de>,
10413 {
10414 const FIELDS: &[&str] = &[
10415 "status",
10416 "version",
10417 ];
10418
10419 #[allow(clippy::enum_variant_names)]
10420 enum GeneratedField {
10421 Status,
10422 Version,
10423 }
10424 impl<'de> serde::Deserialize<'de> for GeneratedField {
10425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10426 where
10427 D: serde::Deserializer<'de>,
10428 {
10429 struct GeneratedVisitor;
10430
10431 impl serde::de::Visitor<'_> for GeneratedVisitor {
10432 type Value = GeneratedField;
10433
10434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10435 write!(formatter, "expected one of: {:?}", &FIELDS)
10436 }
10437
10438 #[allow(unused_variables)]
10439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10440 where
10441 E: serde::de::Error,
10442 {
10443 match value {
10444 "status" => Ok(GeneratedField::Status),
10445 "version" => Ok(GeneratedField::Version),
10446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10447 }
10448 }
10449 }
10450 deserializer.deserialize_identifier(GeneratedVisitor)
10451 }
10452 }
10453 struct GeneratedVisitor;
10454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10455 type Value = DropViewResponse;
10456
10457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10458 formatter.write_str("struct ddl_service.DropViewResponse")
10459 }
10460
10461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
10462 where
10463 V: serde::de::MapAccess<'de>,
10464 {
10465 let mut status__ = None;
10466 let mut version__ = None;
10467 while let Some(k) = map_.next_key()? {
10468 match k {
10469 GeneratedField::Status => {
10470 if status__.is_some() {
10471 return Err(serde::de::Error::duplicate_field("status"));
10472 }
10473 status__ = map_.next_value()?;
10474 }
10475 GeneratedField::Version => {
10476 if version__.is_some() {
10477 return Err(serde::de::Error::duplicate_field("version"));
10478 }
10479 version__ = map_.next_value()?;
10480 }
10481 }
10482 }
10483 Ok(DropViewResponse {
10484 status: status__,
10485 version: version__,
10486 })
10487 }
10488 }
10489 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
10490 }
10491}
10492impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
10493 #[allow(deprecated)]
10494 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10495 where
10496 S: serde::Serializer,
10497 {
10498 use serde::ser::SerializeStruct;
10499 let mut len = 0;
10500 if self.sink_id != 0 {
10501 len += 1;
10502 }
10503 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
10504 if self.sink_id != 0 {
10505 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10506 }
10507 struct_ser.end()
10508 }
10509}
10510impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10511 #[allow(deprecated)]
10512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10513 where
10514 D: serde::Deserializer<'de>,
10515 {
10516 const FIELDS: &[&str] = &[
10517 "sink_id",
10518 "sinkId",
10519 ];
10520
10521 #[allow(clippy::enum_variant_names)]
10522 enum GeneratedField {
10523 SinkId,
10524 }
10525 impl<'de> serde::Deserialize<'de> for GeneratedField {
10526 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10527 where
10528 D: serde::Deserializer<'de>,
10529 {
10530 struct GeneratedVisitor;
10531
10532 impl serde::de::Visitor<'_> for GeneratedVisitor {
10533 type Value = GeneratedField;
10534
10535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10536 write!(formatter, "expected one of: {:?}", &FIELDS)
10537 }
10538
10539 #[allow(unused_variables)]
10540 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10541 where
10542 E: serde::de::Error,
10543 {
10544 match value {
10545 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10546 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10547 }
10548 }
10549 }
10550 deserializer.deserialize_identifier(GeneratedVisitor)
10551 }
10552 }
10553 struct GeneratedVisitor;
10554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10555 type Value = ExpireIcebergTableSnapshotsRequest;
10556
10557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10558 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10559 }
10560
10561 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10562 where
10563 V: serde::de::MapAccess<'de>,
10564 {
10565 let mut sink_id__ = None;
10566 while let Some(k) = map_.next_key()? {
10567 match k {
10568 GeneratedField::SinkId => {
10569 if sink_id__.is_some() {
10570 return Err(serde::de::Error::duplicate_field("sinkId"));
10571 }
10572 sink_id__ =
10573 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10574 ;
10575 }
10576 }
10577 }
10578 Ok(ExpireIcebergTableSnapshotsRequest {
10579 sink_id: sink_id__.unwrap_or_default(),
10580 })
10581 }
10582 }
10583 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10584 }
10585}
10586impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10587 #[allow(deprecated)]
10588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10589 where
10590 S: serde::Serializer,
10591 {
10592 use serde::ser::SerializeStruct;
10593 let mut len = 0;
10594 if self.status.is_some() {
10595 len += 1;
10596 }
10597 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10598 if let Some(v) = self.status.as_ref() {
10599 struct_ser.serialize_field("status", v)?;
10600 }
10601 struct_ser.end()
10602 }
10603}
10604impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10605 #[allow(deprecated)]
10606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10607 where
10608 D: serde::Deserializer<'de>,
10609 {
10610 const FIELDS: &[&str] = &[
10611 "status",
10612 ];
10613
10614 #[allow(clippy::enum_variant_names)]
10615 enum GeneratedField {
10616 Status,
10617 }
10618 impl<'de> serde::Deserialize<'de> for GeneratedField {
10619 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10620 where
10621 D: serde::Deserializer<'de>,
10622 {
10623 struct GeneratedVisitor;
10624
10625 impl serde::de::Visitor<'_> for GeneratedVisitor {
10626 type Value = GeneratedField;
10627
10628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10629 write!(formatter, "expected one of: {:?}", &FIELDS)
10630 }
10631
10632 #[allow(unused_variables)]
10633 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10634 where
10635 E: serde::de::Error,
10636 {
10637 match value {
10638 "status" => Ok(GeneratedField::Status),
10639 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10640 }
10641 }
10642 }
10643 deserializer.deserialize_identifier(GeneratedVisitor)
10644 }
10645 }
10646 struct GeneratedVisitor;
10647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10648 type Value = ExpireIcebergTableSnapshotsResponse;
10649
10650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10651 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10652 }
10653
10654 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10655 where
10656 V: serde::de::MapAccess<'de>,
10657 {
10658 let mut status__ = None;
10659 while let Some(k) = map_.next_key()? {
10660 match k {
10661 GeneratedField::Status => {
10662 if status__.is_some() {
10663 return Err(serde::de::Error::duplicate_field("status"));
10664 }
10665 status__ = map_.next_value()?;
10666 }
10667 }
10668 }
10669 Ok(ExpireIcebergTableSnapshotsResponse {
10670 status: status__,
10671 })
10672 }
10673 }
10674 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10675 }
10676}
10677impl serde::Serialize for GetDdlProgressRequest {
10678 #[allow(deprecated)]
10679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10680 where
10681 S: serde::Serializer,
10682 {
10683 use serde::ser::SerializeStruct;
10684 let len = 0;
10685 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10686 struct_ser.end()
10687 }
10688}
10689impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10690 #[allow(deprecated)]
10691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10692 where
10693 D: serde::Deserializer<'de>,
10694 {
10695 const FIELDS: &[&str] = &[
10696 ];
10697
10698 #[allow(clippy::enum_variant_names)]
10699 enum GeneratedField {
10700 }
10701 impl<'de> serde::Deserialize<'de> for GeneratedField {
10702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10703 where
10704 D: serde::Deserializer<'de>,
10705 {
10706 struct GeneratedVisitor;
10707
10708 impl serde::de::Visitor<'_> for GeneratedVisitor {
10709 type Value = GeneratedField;
10710
10711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10712 write!(formatter, "expected one of: {:?}", &FIELDS)
10713 }
10714
10715 #[allow(unused_variables)]
10716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10717 where
10718 E: serde::de::Error,
10719 {
10720 Err(serde::de::Error::unknown_field(value, FIELDS))
10721 }
10722 }
10723 deserializer.deserialize_identifier(GeneratedVisitor)
10724 }
10725 }
10726 struct GeneratedVisitor;
10727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10728 type Value = GetDdlProgressRequest;
10729
10730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10731 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
10732 }
10733
10734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
10735 where
10736 V: serde::de::MapAccess<'de>,
10737 {
10738 while map_.next_key::<GeneratedField>()?.is_some() {
10739 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10740 }
10741 Ok(GetDdlProgressRequest {
10742 })
10743 }
10744 }
10745 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
10746 }
10747}
10748impl serde::Serialize for GetDdlProgressResponse {
10749 #[allow(deprecated)]
10750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10751 where
10752 S: serde::Serializer,
10753 {
10754 use serde::ser::SerializeStruct;
10755 let mut len = 0;
10756 if !self.ddl_progress.is_empty() {
10757 len += 1;
10758 }
10759 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
10760 if !self.ddl_progress.is_empty() {
10761 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
10762 }
10763 struct_ser.end()
10764 }
10765}
10766impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
10767 #[allow(deprecated)]
10768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10769 where
10770 D: serde::Deserializer<'de>,
10771 {
10772 const FIELDS: &[&str] = &[
10773 "ddl_progress",
10774 "ddlProgress",
10775 ];
10776
10777 #[allow(clippy::enum_variant_names)]
10778 enum GeneratedField {
10779 DdlProgress,
10780 }
10781 impl<'de> serde::Deserialize<'de> for GeneratedField {
10782 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10783 where
10784 D: serde::Deserializer<'de>,
10785 {
10786 struct GeneratedVisitor;
10787
10788 impl serde::de::Visitor<'_> for GeneratedVisitor {
10789 type Value = GeneratedField;
10790
10791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10792 write!(formatter, "expected one of: {:?}", &FIELDS)
10793 }
10794
10795 #[allow(unused_variables)]
10796 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10797 where
10798 E: serde::de::Error,
10799 {
10800 match value {
10801 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10803 }
10804 }
10805 }
10806 deserializer.deserialize_identifier(GeneratedVisitor)
10807 }
10808 }
10809 struct GeneratedVisitor;
10810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10811 type Value = GetDdlProgressResponse;
10812
10813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10814 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10815 }
10816
10817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10818 where
10819 V: serde::de::MapAccess<'de>,
10820 {
10821 let mut ddl_progress__ = None;
10822 while let Some(k) = map_.next_key()? {
10823 match k {
10824 GeneratedField::DdlProgress => {
10825 if ddl_progress__.is_some() {
10826 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10827 }
10828 ddl_progress__ = Some(map_.next_value()?);
10829 }
10830 }
10831 }
10832 Ok(GetDdlProgressResponse {
10833 ddl_progress: ddl_progress__.unwrap_or_default(),
10834 })
10835 }
10836 }
10837 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10838 }
10839}
10840impl serde::Serialize for GetTableRequest {
10841 #[allow(deprecated)]
10842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10843 where
10844 S: serde::Serializer,
10845 {
10846 use serde::ser::SerializeStruct;
10847 let mut len = 0;
10848 if !self.database_name.is_empty() {
10849 len += 1;
10850 }
10851 if !self.table_name.is_empty() {
10852 len += 1;
10853 }
10854 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10855 if !self.database_name.is_empty() {
10856 struct_ser.serialize_field("databaseName", &self.database_name)?;
10857 }
10858 if !self.table_name.is_empty() {
10859 struct_ser.serialize_field("tableName", &self.table_name)?;
10860 }
10861 struct_ser.end()
10862 }
10863}
10864impl<'de> serde::Deserialize<'de> for GetTableRequest {
10865 #[allow(deprecated)]
10866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10867 where
10868 D: serde::Deserializer<'de>,
10869 {
10870 const FIELDS: &[&str] = &[
10871 "database_name",
10872 "databaseName",
10873 "table_name",
10874 "tableName",
10875 ];
10876
10877 #[allow(clippy::enum_variant_names)]
10878 enum GeneratedField {
10879 DatabaseName,
10880 TableName,
10881 }
10882 impl<'de> serde::Deserialize<'de> for GeneratedField {
10883 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10884 where
10885 D: serde::Deserializer<'de>,
10886 {
10887 struct GeneratedVisitor;
10888
10889 impl serde::de::Visitor<'_> for GeneratedVisitor {
10890 type Value = GeneratedField;
10891
10892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10893 write!(formatter, "expected one of: {:?}", &FIELDS)
10894 }
10895
10896 #[allow(unused_variables)]
10897 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10898 where
10899 E: serde::de::Error,
10900 {
10901 match value {
10902 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10903 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10904 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10905 }
10906 }
10907 }
10908 deserializer.deserialize_identifier(GeneratedVisitor)
10909 }
10910 }
10911 struct GeneratedVisitor;
10912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10913 type Value = GetTableRequest;
10914
10915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10916 formatter.write_str("struct ddl_service.GetTableRequest")
10917 }
10918
10919 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10920 where
10921 V: serde::de::MapAccess<'de>,
10922 {
10923 let mut database_name__ = None;
10924 let mut table_name__ = None;
10925 while let Some(k) = map_.next_key()? {
10926 match k {
10927 GeneratedField::DatabaseName => {
10928 if database_name__.is_some() {
10929 return Err(serde::de::Error::duplicate_field("databaseName"));
10930 }
10931 database_name__ = Some(map_.next_value()?);
10932 }
10933 GeneratedField::TableName => {
10934 if table_name__.is_some() {
10935 return Err(serde::de::Error::duplicate_field("tableName"));
10936 }
10937 table_name__ = Some(map_.next_value()?);
10938 }
10939 }
10940 }
10941 Ok(GetTableRequest {
10942 database_name: database_name__.unwrap_or_default(),
10943 table_name: table_name__.unwrap_or_default(),
10944 })
10945 }
10946 }
10947 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10948 }
10949}
10950impl serde::Serialize for GetTableResponse {
10951 #[allow(deprecated)]
10952 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10953 where
10954 S: serde::Serializer,
10955 {
10956 use serde::ser::SerializeStruct;
10957 let mut len = 0;
10958 if self.table.is_some() {
10959 len += 1;
10960 }
10961 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10962 if let Some(v) = self.table.as_ref() {
10963 struct_ser.serialize_field("table", v)?;
10964 }
10965 struct_ser.end()
10966 }
10967}
10968impl<'de> serde::Deserialize<'de> for GetTableResponse {
10969 #[allow(deprecated)]
10970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10971 where
10972 D: serde::Deserializer<'de>,
10973 {
10974 const FIELDS: &[&str] = &[
10975 "table",
10976 ];
10977
10978 #[allow(clippy::enum_variant_names)]
10979 enum GeneratedField {
10980 Table,
10981 }
10982 impl<'de> serde::Deserialize<'de> for GeneratedField {
10983 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10984 where
10985 D: serde::Deserializer<'de>,
10986 {
10987 struct GeneratedVisitor;
10988
10989 impl serde::de::Visitor<'_> for GeneratedVisitor {
10990 type Value = GeneratedField;
10991
10992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10993 write!(formatter, "expected one of: {:?}", &FIELDS)
10994 }
10995
10996 #[allow(unused_variables)]
10997 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10998 where
10999 E: serde::de::Error,
11000 {
11001 match value {
11002 "table" => Ok(GeneratedField::Table),
11003 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11004 }
11005 }
11006 }
11007 deserializer.deserialize_identifier(GeneratedVisitor)
11008 }
11009 }
11010 struct GeneratedVisitor;
11011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11012 type Value = GetTableResponse;
11013
11014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11015 formatter.write_str("struct ddl_service.GetTableResponse")
11016 }
11017
11018 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
11019 where
11020 V: serde::de::MapAccess<'de>,
11021 {
11022 let mut table__ = None;
11023 while let Some(k) = map_.next_key()? {
11024 match k {
11025 GeneratedField::Table => {
11026 if table__.is_some() {
11027 return Err(serde::de::Error::duplicate_field("table"));
11028 }
11029 table__ = map_.next_value()?;
11030 }
11031 }
11032 }
11033 Ok(GetTableResponse {
11034 table: table__,
11035 })
11036 }
11037 }
11038 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
11039 }
11040}
11041impl serde::Serialize for GetTablesRequest {
11042 #[allow(deprecated)]
11043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11044 where
11045 S: serde::Serializer,
11046 {
11047 use serde::ser::SerializeStruct;
11048 let mut len = 0;
11049 if !self.table_ids.is_empty() {
11050 len += 1;
11051 }
11052 if self.include_dropped_tables {
11053 len += 1;
11054 }
11055 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
11056 if !self.table_ids.is_empty() {
11057 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11058 }
11059 if self.include_dropped_tables {
11060 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
11061 }
11062 struct_ser.end()
11063 }
11064}
11065impl<'de> serde::Deserialize<'de> for GetTablesRequest {
11066 #[allow(deprecated)]
11067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11068 where
11069 D: serde::Deserializer<'de>,
11070 {
11071 const FIELDS: &[&str] = &[
11072 "table_ids",
11073 "tableIds",
11074 "include_dropped_tables",
11075 "includeDroppedTables",
11076 ];
11077
11078 #[allow(clippy::enum_variant_names)]
11079 enum GeneratedField {
11080 TableIds,
11081 IncludeDroppedTables,
11082 }
11083 impl<'de> serde::Deserialize<'de> for GeneratedField {
11084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11085 where
11086 D: serde::Deserializer<'de>,
11087 {
11088 struct GeneratedVisitor;
11089
11090 impl serde::de::Visitor<'_> for GeneratedVisitor {
11091 type Value = GeneratedField;
11092
11093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11094 write!(formatter, "expected one of: {:?}", &FIELDS)
11095 }
11096
11097 #[allow(unused_variables)]
11098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11099 where
11100 E: serde::de::Error,
11101 {
11102 match value {
11103 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11104 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
11105 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11106 }
11107 }
11108 }
11109 deserializer.deserialize_identifier(GeneratedVisitor)
11110 }
11111 }
11112 struct GeneratedVisitor;
11113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11114 type Value = GetTablesRequest;
11115
11116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11117 formatter.write_str("struct ddl_service.GetTablesRequest")
11118 }
11119
11120 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
11121 where
11122 V: serde::de::MapAccess<'de>,
11123 {
11124 let mut table_ids__ = None;
11125 let mut include_dropped_tables__ = None;
11126 while let Some(k) = map_.next_key()? {
11127 match k {
11128 GeneratedField::TableIds => {
11129 if table_ids__.is_some() {
11130 return Err(serde::de::Error::duplicate_field("tableIds"));
11131 }
11132 table_ids__ =
11133 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11134 .into_iter().map(|x| x.0).collect())
11135 ;
11136 }
11137 GeneratedField::IncludeDroppedTables => {
11138 if include_dropped_tables__.is_some() {
11139 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
11140 }
11141 include_dropped_tables__ = Some(map_.next_value()?);
11142 }
11143 }
11144 }
11145 Ok(GetTablesRequest {
11146 table_ids: table_ids__.unwrap_or_default(),
11147 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
11148 })
11149 }
11150 }
11151 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
11152 }
11153}
11154impl serde::Serialize for GetTablesResponse {
11155 #[allow(deprecated)]
11156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11157 where
11158 S: serde::Serializer,
11159 {
11160 use serde::ser::SerializeStruct;
11161 let mut len = 0;
11162 if !self.tables.is_empty() {
11163 len += 1;
11164 }
11165 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
11166 if !self.tables.is_empty() {
11167 struct_ser.serialize_field("tables", &self.tables)?;
11168 }
11169 struct_ser.end()
11170 }
11171}
11172impl<'de> serde::Deserialize<'de> for GetTablesResponse {
11173 #[allow(deprecated)]
11174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11175 where
11176 D: serde::Deserializer<'de>,
11177 {
11178 const FIELDS: &[&str] = &[
11179 "tables",
11180 ];
11181
11182 #[allow(clippy::enum_variant_names)]
11183 enum GeneratedField {
11184 Tables,
11185 }
11186 impl<'de> serde::Deserialize<'de> for GeneratedField {
11187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11188 where
11189 D: serde::Deserializer<'de>,
11190 {
11191 struct GeneratedVisitor;
11192
11193 impl serde::de::Visitor<'_> for GeneratedVisitor {
11194 type Value = GeneratedField;
11195
11196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11197 write!(formatter, "expected one of: {:?}", &FIELDS)
11198 }
11199
11200 #[allow(unused_variables)]
11201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11202 where
11203 E: serde::de::Error,
11204 {
11205 match value {
11206 "tables" => Ok(GeneratedField::Tables),
11207 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11208 }
11209 }
11210 }
11211 deserializer.deserialize_identifier(GeneratedVisitor)
11212 }
11213 }
11214 struct GeneratedVisitor;
11215 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11216 type Value = GetTablesResponse;
11217
11218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11219 formatter.write_str("struct ddl_service.GetTablesResponse")
11220 }
11221
11222 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
11223 where
11224 V: serde::de::MapAccess<'de>,
11225 {
11226 let mut tables__ = None;
11227 while let Some(k) = map_.next_key()? {
11228 match k {
11229 GeneratedField::Tables => {
11230 if tables__.is_some() {
11231 return Err(serde::de::Error::duplicate_field("tables"));
11232 }
11233 tables__ = Some(
11234 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11235 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11236 );
11237 }
11238 }
11239 }
11240 Ok(GetTablesResponse {
11241 tables: tables__.unwrap_or_default(),
11242 })
11243 }
11244 }
11245 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
11246 }
11247}
11248impl serde::Serialize for ListConnectionsRequest {
11249 #[allow(deprecated)]
11250 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11251 where
11252 S: serde::Serializer,
11253 {
11254 use serde::ser::SerializeStruct;
11255 let len = 0;
11256 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
11257 struct_ser.end()
11258 }
11259}
11260impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
11261 #[allow(deprecated)]
11262 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11263 where
11264 D: serde::Deserializer<'de>,
11265 {
11266 const FIELDS: &[&str] = &[
11267 ];
11268
11269 #[allow(clippy::enum_variant_names)]
11270 enum GeneratedField {
11271 }
11272 impl<'de> serde::Deserialize<'de> for GeneratedField {
11273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11274 where
11275 D: serde::Deserializer<'de>,
11276 {
11277 struct GeneratedVisitor;
11278
11279 impl serde::de::Visitor<'_> for GeneratedVisitor {
11280 type Value = GeneratedField;
11281
11282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11283 write!(formatter, "expected one of: {:?}", &FIELDS)
11284 }
11285
11286 #[allow(unused_variables)]
11287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11288 where
11289 E: serde::de::Error,
11290 {
11291 Err(serde::de::Error::unknown_field(value, FIELDS))
11292 }
11293 }
11294 deserializer.deserialize_identifier(GeneratedVisitor)
11295 }
11296 }
11297 struct GeneratedVisitor;
11298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11299 type Value = ListConnectionsRequest;
11300
11301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11302 formatter.write_str("struct ddl_service.ListConnectionsRequest")
11303 }
11304
11305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
11306 where
11307 V: serde::de::MapAccess<'de>,
11308 {
11309 while map_.next_key::<GeneratedField>()?.is_some() {
11310 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11311 }
11312 Ok(ListConnectionsRequest {
11313 })
11314 }
11315 }
11316 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
11317 }
11318}
11319impl serde::Serialize for ListConnectionsResponse {
11320 #[allow(deprecated)]
11321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11322 where
11323 S: serde::Serializer,
11324 {
11325 use serde::ser::SerializeStruct;
11326 let mut len = 0;
11327 if !self.connections.is_empty() {
11328 len += 1;
11329 }
11330 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
11331 if !self.connections.is_empty() {
11332 struct_ser.serialize_field("connections", &self.connections)?;
11333 }
11334 struct_ser.end()
11335 }
11336}
11337impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
11338 #[allow(deprecated)]
11339 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11340 where
11341 D: serde::Deserializer<'de>,
11342 {
11343 const FIELDS: &[&str] = &[
11344 "connections",
11345 ];
11346
11347 #[allow(clippy::enum_variant_names)]
11348 enum GeneratedField {
11349 Connections,
11350 }
11351 impl<'de> serde::Deserialize<'de> for GeneratedField {
11352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11353 where
11354 D: serde::Deserializer<'de>,
11355 {
11356 struct GeneratedVisitor;
11357
11358 impl serde::de::Visitor<'_> for GeneratedVisitor {
11359 type Value = GeneratedField;
11360
11361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11362 write!(formatter, "expected one of: {:?}", &FIELDS)
11363 }
11364
11365 #[allow(unused_variables)]
11366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11367 where
11368 E: serde::de::Error,
11369 {
11370 match value {
11371 "connections" => Ok(GeneratedField::Connections),
11372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11373 }
11374 }
11375 }
11376 deserializer.deserialize_identifier(GeneratedVisitor)
11377 }
11378 }
11379 struct GeneratedVisitor;
11380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11381 type Value = ListConnectionsResponse;
11382
11383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11384 formatter.write_str("struct ddl_service.ListConnectionsResponse")
11385 }
11386
11387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
11388 where
11389 V: serde::de::MapAccess<'de>,
11390 {
11391 let mut connections__ = None;
11392 while let Some(k) = map_.next_key()? {
11393 match k {
11394 GeneratedField::Connections => {
11395 if connections__.is_some() {
11396 return Err(serde::de::Error::duplicate_field("connections"));
11397 }
11398 connections__ = Some(map_.next_value()?);
11399 }
11400 }
11401 }
11402 Ok(ListConnectionsResponse {
11403 connections: connections__.unwrap_or_default(),
11404 })
11405 }
11406 }
11407 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
11408 }
11409}
11410impl serde::Serialize for ReplaceJobPlan {
11411 #[allow(deprecated)]
11412 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11413 where
11414 S: serde::Serializer,
11415 {
11416 use serde::ser::SerializeStruct;
11417 let mut len = 0;
11418 if self.fragment_graph.is_some() {
11419 len += 1;
11420 }
11421 if self.replace_job.is_some() {
11422 len += 1;
11423 }
11424 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
11425 if let Some(v) = self.fragment_graph.as_ref() {
11426 struct_ser.serialize_field("fragmentGraph", v)?;
11427 }
11428 if let Some(v) = self.replace_job.as_ref() {
11429 match v {
11430 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
11431 struct_ser.serialize_field("replaceTable", v)?;
11432 }
11433 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
11434 struct_ser.serialize_field("replaceSource", v)?;
11435 }
11436 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
11437 struct_ser.serialize_field("replaceMaterializedView", v)?;
11438 }
11439 }
11440 }
11441 struct_ser.end()
11442 }
11443}
11444impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
11445 #[allow(deprecated)]
11446 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11447 where
11448 D: serde::Deserializer<'de>,
11449 {
11450 const FIELDS: &[&str] = &[
11451 "fragment_graph",
11452 "fragmentGraph",
11453 "replace_table",
11454 "replaceTable",
11455 "replace_source",
11456 "replaceSource",
11457 "replace_materialized_view",
11458 "replaceMaterializedView",
11459 ];
11460
11461 #[allow(clippy::enum_variant_names)]
11462 enum GeneratedField {
11463 FragmentGraph,
11464 ReplaceTable,
11465 ReplaceSource,
11466 ReplaceMaterializedView,
11467 }
11468 impl<'de> serde::Deserialize<'de> for GeneratedField {
11469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11470 where
11471 D: serde::Deserializer<'de>,
11472 {
11473 struct GeneratedVisitor;
11474
11475 impl serde::de::Visitor<'_> for GeneratedVisitor {
11476 type Value = GeneratedField;
11477
11478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11479 write!(formatter, "expected one of: {:?}", &FIELDS)
11480 }
11481
11482 #[allow(unused_variables)]
11483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11484 where
11485 E: serde::de::Error,
11486 {
11487 match value {
11488 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
11489 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
11490 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
11491 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
11492 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11493 }
11494 }
11495 }
11496 deserializer.deserialize_identifier(GeneratedVisitor)
11497 }
11498 }
11499 struct GeneratedVisitor;
11500 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11501 type Value = ReplaceJobPlan;
11502
11503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11504 formatter.write_str("struct ddl_service.ReplaceJobPlan")
11505 }
11506
11507 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
11508 where
11509 V: serde::de::MapAccess<'de>,
11510 {
11511 let mut fragment_graph__ = None;
11512 let mut replace_job__ = None;
11513 while let Some(k) = map_.next_key()? {
11514 match k {
11515 GeneratedField::FragmentGraph => {
11516 if fragment_graph__.is_some() {
11517 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11518 }
11519 fragment_graph__ = map_.next_value()?;
11520 }
11521 GeneratedField::ReplaceTable => {
11522 if replace_job__.is_some() {
11523 return Err(serde::de::Error::duplicate_field("replaceTable"));
11524 }
11525 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11526;
11527 }
11528 GeneratedField::ReplaceSource => {
11529 if replace_job__.is_some() {
11530 return Err(serde::de::Error::duplicate_field("replaceSource"));
11531 }
11532 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11533;
11534 }
11535 GeneratedField::ReplaceMaterializedView => {
11536 if replace_job__.is_some() {
11537 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11538 }
11539 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11540;
11541 }
11542 }
11543 }
11544 Ok(ReplaceJobPlan {
11545 fragment_graph: fragment_graph__,
11546 replace_job: replace_job__,
11547 })
11548 }
11549 }
11550 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11551 }
11552}
11553impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
11554 #[allow(deprecated)]
11555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11556 where
11557 S: serde::Serializer,
11558 {
11559 use serde::ser::SerializeStruct;
11560 let mut len = 0;
11561 if self.table.is_some() {
11562 len += 1;
11563 }
11564 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11565 if let Some(v) = self.table.as_ref() {
11566 struct_ser.serialize_field("table", v)?;
11567 }
11568 struct_ser.end()
11569 }
11570}
11571impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
11572 #[allow(deprecated)]
11573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11574 where
11575 D: serde::Deserializer<'de>,
11576 {
11577 const FIELDS: &[&str] = &[
11578 "table",
11579 ];
11580
11581 #[allow(clippy::enum_variant_names)]
11582 enum GeneratedField {
11583 Table,
11584 }
11585 impl<'de> serde::Deserialize<'de> for GeneratedField {
11586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11587 where
11588 D: serde::Deserializer<'de>,
11589 {
11590 struct GeneratedVisitor;
11591
11592 impl serde::de::Visitor<'_> for GeneratedVisitor {
11593 type Value = GeneratedField;
11594
11595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11596 write!(formatter, "expected one of: {:?}", &FIELDS)
11597 }
11598
11599 #[allow(unused_variables)]
11600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11601 where
11602 E: serde::de::Error,
11603 {
11604 match value {
11605 "table" => Ok(GeneratedField::Table),
11606 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11607 }
11608 }
11609 }
11610 deserializer.deserialize_identifier(GeneratedVisitor)
11611 }
11612 }
11613 struct GeneratedVisitor;
11614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11615 type Value = replace_job_plan::ReplaceMaterializedView;
11616
11617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11618 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11619 }
11620
11621 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11622 where
11623 V: serde::de::MapAccess<'de>,
11624 {
11625 let mut table__ = None;
11626 while let Some(k) = map_.next_key()? {
11627 match k {
11628 GeneratedField::Table => {
11629 if table__.is_some() {
11630 return Err(serde::de::Error::duplicate_field("table"));
11631 }
11632 table__ = map_.next_value()?;
11633 }
11634 }
11635 }
11636 Ok(replace_job_plan::ReplaceMaterializedView {
11637 table: table__,
11638 })
11639 }
11640 }
11641 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11642 }
11643}
11644impl serde::Serialize for replace_job_plan::ReplaceSource {
11645 #[allow(deprecated)]
11646 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11647 where
11648 S: serde::Serializer,
11649 {
11650 use serde::ser::SerializeStruct;
11651 let mut len = 0;
11652 if self.source.is_some() {
11653 len += 1;
11654 }
11655 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11656 if let Some(v) = self.source.as_ref() {
11657 struct_ser.serialize_field("source", v)?;
11658 }
11659 struct_ser.end()
11660 }
11661}
11662impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11663 #[allow(deprecated)]
11664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11665 where
11666 D: serde::Deserializer<'de>,
11667 {
11668 const FIELDS: &[&str] = &[
11669 "source",
11670 ];
11671
11672 #[allow(clippy::enum_variant_names)]
11673 enum GeneratedField {
11674 Source,
11675 }
11676 impl<'de> serde::Deserialize<'de> for GeneratedField {
11677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11678 where
11679 D: serde::Deserializer<'de>,
11680 {
11681 struct GeneratedVisitor;
11682
11683 impl serde::de::Visitor<'_> for GeneratedVisitor {
11684 type Value = GeneratedField;
11685
11686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11687 write!(formatter, "expected one of: {:?}", &FIELDS)
11688 }
11689
11690 #[allow(unused_variables)]
11691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11692 where
11693 E: serde::de::Error,
11694 {
11695 match value {
11696 "source" => Ok(GeneratedField::Source),
11697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11698 }
11699 }
11700 }
11701 deserializer.deserialize_identifier(GeneratedVisitor)
11702 }
11703 }
11704 struct GeneratedVisitor;
11705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11706 type Value = replace_job_plan::ReplaceSource;
11707
11708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11709 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
11710 }
11711
11712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
11713 where
11714 V: serde::de::MapAccess<'de>,
11715 {
11716 let mut source__ = None;
11717 while let Some(k) = map_.next_key()? {
11718 match k {
11719 GeneratedField::Source => {
11720 if source__.is_some() {
11721 return Err(serde::de::Error::duplicate_field("source"));
11722 }
11723 source__ = map_.next_value()?;
11724 }
11725 }
11726 }
11727 Ok(replace_job_plan::ReplaceSource {
11728 source: source__,
11729 })
11730 }
11731 }
11732 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
11733 }
11734}
11735impl serde::Serialize for replace_job_plan::ReplaceTable {
11736 #[allow(deprecated)]
11737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11738 where
11739 S: serde::Serializer,
11740 {
11741 use serde::ser::SerializeStruct;
11742 let mut len = 0;
11743 if self.table.is_some() {
11744 len += 1;
11745 }
11746 if self.source.is_some() {
11747 len += 1;
11748 }
11749 if self.job_type != 0 {
11750 len += 1;
11751 }
11752 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
11753 if let Some(v) = self.table.as_ref() {
11754 struct_ser.serialize_field("table", v)?;
11755 }
11756 if let Some(v) = self.source.as_ref() {
11757 struct_ser.serialize_field("source", v)?;
11758 }
11759 if self.job_type != 0 {
11760 let v = TableJobType::try_from(self.job_type)
11761 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
11762 struct_ser.serialize_field("jobType", &v)?;
11763 }
11764 struct_ser.end()
11765 }
11766}
11767impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
11768 #[allow(deprecated)]
11769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11770 where
11771 D: serde::Deserializer<'de>,
11772 {
11773 const FIELDS: &[&str] = &[
11774 "table",
11775 "source",
11776 "job_type",
11777 "jobType",
11778 ];
11779
11780 #[allow(clippy::enum_variant_names)]
11781 enum GeneratedField {
11782 Table,
11783 Source,
11784 JobType,
11785 }
11786 impl<'de> serde::Deserialize<'de> for GeneratedField {
11787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11788 where
11789 D: serde::Deserializer<'de>,
11790 {
11791 struct GeneratedVisitor;
11792
11793 impl serde::de::Visitor<'_> for GeneratedVisitor {
11794 type Value = GeneratedField;
11795
11796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11797 write!(formatter, "expected one of: {:?}", &FIELDS)
11798 }
11799
11800 #[allow(unused_variables)]
11801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11802 where
11803 E: serde::de::Error,
11804 {
11805 match value {
11806 "table" => Ok(GeneratedField::Table),
11807 "source" => Ok(GeneratedField::Source),
11808 "jobType" | "job_type" => Ok(GeneratedField::JobType),
11809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11810 }
11811 }
11812 }
11813 deserializer.deserialize_identifier(GeneratedVisitor)
11814 }
11815 }
11816 struct GeneratedVisitor;
11817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11818 type Value = replace_job_plan::ReplaceTable;
11819
11820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11821 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11822 }
11823
11824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11825 where
11826 V: serde::de::MapAccess<'de>,
11827 {
11828 let mut table__ = None;
11829 let mut source__ = None;
11830 let mut job_type__ = None;
11831 while let Some(k) = map_.next_key()? {
11832 match k {
11833 GeneratedField::Table => {
11834 if table__.is_some() {
11835 return Err(serde::de::Error::duplicate_field("table"));
11836 }
11837 table__ = map_.next_value()?;
11838 }
11839 GeneratedField::Source => {
11840 if source__.is_some() {
11841 return Err(serde::de::Error::duplicate_field("source"));
11842 }
11843 source__ = map_.next_value()?;
11844 }
11845 GeneratedField::JobType => {
11846 if job_type__.is_some() {
11847 return Err(serde::de::Error::duplicate_field("jobType"));
11848 }
11849 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11850 }
11851 }
11852 }
11853 Ok(replace_job_plan::ReplaceTable {
11854 table: table__,
11855 source: source__,
11856 job_type: job_type__.unwrap_or_default(),
11857 })
11858 }
11859 }
11860 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11861 }
11862}
11863impl serde::Serialize for ReplaceJobPlanRequest {
11864 #[allow(deprecated)]
11865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11866 where
11867 S: serde::Serializer,
11868 {
11869 use serde::ser::SerializeStruct;
11870 let mut len = 0;
11871 if self.plan.is_some() {
11872 len += 1;
11873 }
11874 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11875 if let Some(v) = self.plan.as_ref() {
11876 struct_ser.serialize_field("plan", v)?;
11877 }
11878 struct_ser.end()
11879 }
11880}
11881impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11882 #[allow(deprecated)]
11883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11884 where
11885 D: serde::Deserializer<'de>,
11886 {
11887 const FIELDS: &[&str] = &[
11888 "plan",
11889 ];
11890
11891 #[allow(clippy::enum_variant_names)]
11892 enum GeneratedField {
11893 Plan,
11894 }
11895 impl<'de> serde::Deserialize<'de> for GeneratedField {
11896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11897 where
11898 D: serde::Deserializer<'de>,
11899 {
11900 struct GeneratedVisitor;
11901
11902 impl serde::de::Visitor<'_> for GeneratedVisitor {
11903 type Value = GeneratedField;
11904
11905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11906 write!(formatter, "expected one of: {:?}", &FIELDS)
11907 }
11908
11909 #[allow(unused_variables)]
11910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11911 where
11912 E: serde::de::Error,
11913 {
11914 match value {
11915 "plan" => Ok(GeneratedField::Plan),
11916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11917 }
11918 }
11919 }
11920 deserializer.deserialize_identifier(GeneratedVisitor)
11921 }
11922 }
11923 struct GeneratedVisitor;
11924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11925 type Value = ReplaceJobPlanRequest;
11926
11927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11928 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11929 }
11930
11931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11932 where
11933 V: serde::de::MapAccess<'de>,
11934 {
11935 let mut plan__ = None;
11936 while let Some(k) = map_.next_key()? {
11937 match k {
11938 GeneratedField::Plan => {
11939 if plan__.is_some() {
11940 return Err(serde::de::Error::duplicate_field("plan"));
11941 }
11942 plan__ = map_.next_value()?;
11943 }
11944 }
11945 }
11946 Ok(ReplaceJobPlanRequest {
11947 plan: plan__,
11948 })
11949 }
11950 }
11951 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11952 }
11953}
11954impl serde::Serialize for ReplaceJobPlanResponse {
11955 #[allow(deprecated)]
11956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11957 where
11958 S: serde::Serializer,
11959 {
11960 use serde::ser::SerializeStruct;
11961 let mut len = 0;
11962 if self.status.is_some() {
11963 len += 1;
11964 }
11965 if self.version.is_some() {
11966 len += 1;
11967 }
11968 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11969 if let Some(v) = self.status.as_ref() {
11970 struct_ser.serialize_field("status", v)?;
11971 }
11972 if let Some(v) = self.version.as_ref() {
11973 struct_ser.serialize_field("version", v)?;
11974 }
11975 struct_ser.end()
11976 }
11977}
11978impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
11979 #[allow(deprecated)]
11980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11981 where
11982 D: serde::Deserializer<'de>,
11983 {
11984 const FIELDS: &[&str] = &[
11985 "status",
11986 "version",
11987 ];
11988
11989 #[allow(clippy::enum_variant_names)]
11990 enum GeneratedField {
11991 Status,
11992 Version,
11993 }
11994 impl<'de> serde::Deserialize<'de> for GeneratedField {
11995 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11996 where
11997 D: serde::Deserializer<'de>,
11998 {
11999 struct GeneratedVisitor;
12000
12001 impl serde::de::Visitor<'_> for GeneratedVisitor {
12002 type Value = GeneratedField;
12003
12004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12005 write!(formatter, "expected one of: {:?}", &FIELDS)
12006 }
12007
12008 #[allow(unused_variables)]
12009 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12010 where
12011 E: serde::de::Error,
12012 {
12013 match value {
12014 "status" => Ok(GeneratedField::Status),
12015 "version" => Ok(GeneratedField::Version),
12016 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12017 }
12018 }
12019 }
12020 deserializer.deserialize_identifier(GeneratedVisitor)
12021 }
12022 }
12023 struct GeneratedVisitor;
12024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12025 type Value = ReplaceJobPlanResponse;
12026
12027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12028 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
12029 }
12030
12031 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
12032 where
12033 V: serde::de::MapAccess<'de>,
12034 {
12035 let mut status__ = None;
12036 let mut version__ = None;
12037 while let Some(k) = map_.next_key()? {
12038 match k {
12039 GeneratedField::Status => {
12040 if status__.is_some() {
12041 return Err(serde::de::Error::duplicate_field("status"));
12042 }
12043 status__ = map_.next_value()?;
12044 }
12045 GeneratedField::Version => {
12046 if version__.is_some() {
12047 return Err(serde::de::Error::duplicate_field("version"));
12048 }
12049 version__ = map_.next_value()?;
12050 }
12051 }
12052 }
12053 Ok(ReplaceJobPlanResponse {
12054 status: status__,
12055 version: version__,
12056 })
12057 }
12058 }
12059 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
12060 }
12061}
12062impl serde::Serialize for ResetSourceRequest {
12063 #[allow(deprecated)]
12064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12065 where
12066 S: serde::Serializer,
12067 {
12068 use serde::ser::SerializeStruct;
12069 let mut len = 0;
12070 if self.source_id != 0 {
12071 len += 1;
12072 }
12073 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
12074 if self.source_id != 0 {
12075 struct_ser.serialize_field("sourceId", &self.source_id)?;
12076 }
12077 struct_ser.end()
12078 }
12079}
12080impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
12081 #[allow(deprecated)]
12082 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12083 where
12084 D: serde::Deserializer<'de>,
12085 {
12086 const FIELDS: &[&str] = &[
12087 "source_id",
12088 "sourceId",
12089 ];
12090
12091 #[allow(clippy::enum_variant_names)]
12092 enum GeneratedField {
12093 SourceId,
12094 }
12095 impl<'de> serde::Deserialize<'de> for GeneratedField {
12096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12097 where
12098 D: serde::Deserializer<'de>,
12099 {
12100 struct GeneratedVisitor;
12101
12102 impl serde::de::Visitor<'_> for GeneratedVisitor {
12103 type Value = GeneratedField;
12104
12105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12106 write!(formatter, "expected one of: {:?}", &FIELDS)
12107 }
12108
12109 #[allow(unused_variables)]
12110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12111 where
12112 E: serde::de::Error,
12113 {
12114 match value {
12115 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12117 }
12118 }
12119 }
12120 deserializer.deserialize_identifier(GeneratedVisitor)
12121 }
12122 }
12123 struct GeneratedVisitor;
12124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12125 type Value = ResetSourceRequest;
12126
12127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12128 formatter.write_str("struct ddl_service.ResetSourceRequest")
12129 }
12130
12131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
12132 where
12133 V: serde::de::MapAccess<'de>,
12134 {
12135 let mut source_id__ = None;
12136 while let Some(k) = map_.next_key()? {
12137 match k {
12138 GeneratedField::SourceId => {
12139 if source_id__.is_some() {
12140 return Err(serde::de::Error::duplicate_field("sourceId"));
12141 }
12142 source_id__ =
12143 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12144 ;
12145 }
12146 }
12147 }
12148 Ok(ResetSourceRequest {
12149 source_id: source_id__.unwrap_or_default(),
12150 })
12151 }
12152 }
12153 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
12154 }
12155}
12156impl serde::Serialize for ResetSourceResponse {
12157 #[allow(deprecated)]
12158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12159 where
12160 S: serde::Serializer,
12161 {
12162 use serde::ser::SerializeStruct;
12163 let mut len = 0;
12164 if self.status.is_some() {
12165 len += 1;
12166 }
12167 if self.version.is_some() {
12168 len += 1;
12169 }
12170 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
12171 if let Some(v) = self.status.as_ref() {
12172 struct_ser.serialize_field("status", v)?;
12173 }
12174 if let Some(v) = self.version.as_ref() {
12175 struct_ser.serialize_field("version", v)?;
12176 }
12177 struct_ser.end()
12178 }
12179}
12180impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
12181 #[allow(deprecated)]
12182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12183 where
12184 D: serde::Deserializer<'de>,
12185 {
12186 const FIELDS: &[&str] = &[
12187 "status",
12188 "version",
12189 ];
12190
12191 #[allow(clippy::enum_variant_names)]
12192 enum GeneratedField {
12193 Status,
12194 Version,
12195 }
12196 impl<'de> serde::Deserialize<'de> for GeneratedField {
12197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12198 where
12199 D: serde::Deserializer<'de>,
12200 {
12201 struct GeneratedVisitor;
12202
12203 impl serde::de::Visitor<'_> for GeneratedVisitor {
12204 type Value = GeneratedField;
12205
12206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12207 write!(formatter, "expected one of: {:?}", &FIELDS)
12208 }
12209
12210 #[allow(unused_variables)]
12211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12212 where
12213 E: serde::de::Error,
12214 {
12215 match value {
12216 "status" => Ok(GeneratedField::Status),
12217 "version" => Ok(GeneratedField::Version),
12218 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12219 }
12220 }
12221 }
12222 deserializer.deserialize_identifier(GeneratedVisitor)
12223 }
12224 }
12225 struct GeneratedVisitor;
12226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12227 type Value = ResetSourceResponse;
12228
12229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12230 formatter.write_str("struct ddl_service.ResetSourceResponse")
12231 }
12232
12233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
12234 where
12235 V: serde::de::MapAccess<'de>,
12236 {
12237 let mut status__ = None;
12238 let mut version__ = None;
12239 while let Some(k) = map_.next_key()? {
12240 match k {
12241 GeneratedField::Status => {
12242 if status__.is_some() {
12243 return Err(serde::de::Error::duplicate_field("status"));
12244 }
12245 status__ = map_.next_value()?;
12246 }
12247 GeneratedField::Version => {
12248 if version__.is_some() {
12249 return Err(serde::de::Error::duplicate_field("version"));
12250 }
12251 version__ = map_.next_value()?;
12252 }
12253 }
12254 }
12255 Ok(ResetSourceResponse {
12256 status: status__,
12257 version: version__,
12258 })
12259 }
12260 }
12261 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
12262 }
12263}
12264impl serde::Serialize for RisectlListStateTablesRequest {
12265 #[allow(deprecated)]
12266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12267 where
12268 S: serde::Serializer,
12269 {
12270 use serde::ser::SerializeStruct;
12271 let len = 0;
12272 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
12273 struct_ser.end()
12274 }
12275}
12276impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
12277 #[allow(deprecated)]
12278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12279 where
12280 D: serde::Deserializer<'de>,
12281 {
12282 const FIELDS: &[&str] = &[
12283 ];
12284
12285 #[allow(clippy::enum_variant_names)]
12286 enum GeneratedField {
12287 }
12288 impl<'de> serde::Deserialize<'de> for GeneratedField {
12289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12290 where
12291 D: serde::Deserializer<'de>,
12292 {
12293 struct GeneratedVisitor;
12294
12295 impl serde::de::Visitor<'_> for GeneratedVisitor {
12296 type Value = GeneratedField;
12297
12298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12299 write!(formatter, "expected one of: {:?}", &FIELDS)
12300 }
12301
12302 #[allow(unused_variables)]
12303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12304 where
12305 E: serde::de::Error,
12306 {
12307 Err(serde::de::Error::unknown_field(value, FIELDS))
12308 }
12309 }
12310 deserializer.deserialize_identifier(GeneratedVisitor)
12311 }
12312 }
12313 struct GeneratedVisitor;
12314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12315 type Value = RisectlListStateTablesRequest;
12316
12317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12318 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
12319 }
12320
12321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
12322 where
12323 V: serde::de::MapAccess<'de>,
12324 {
12325 while map_.next_key::<GeneratedField>()?.is_some() {
12326 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12327 }
12328 Ok(RisectlListStateTablesRequest {
12329 })
12330 }
12331 }
12332 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
12333 }
12334}
12335impl serde::Serialize for RisectlListStateTablesResponse {
12336 #[allow(deprecated)]
12337 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12338 where
12339 S: serde::Serializer,
12340 {
12341 use serde::ser::SerializeStruct;
12342 let mut len = 0;
12343 if !self.tables.is_empty() {
12344 len += 1;
12345 }
12346 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
12347 if !self.tables.is_empty() {
12348 struct_ser.serialize_field("tables", &self.tables)?;
12349 }
12350 struct_ser.end()
12351 }
12352}
12353impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
12354 #[allow(deprecated)]
12355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12356 where
12357 D: serde::Deserializer<'de>,
12358 {
12359 const FIELDS: &[&str] = &[
12360 "tables",
12361 ];
12362
12363 #[allow(clippy::enum_variant_names)]
12364 enum GeneratedField {
12365 Tables,
12366 }
12367 impl<'de> serde::Deserialize<'de> for GeneratedField {
12368 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12369 where
12370 D: serde::Deserializer<'de>,
12371 {
12372 struct GeneratedVisitor;
12373
12374 impl serde::de::Visitor<'_> for GeneratedVisitor {
12375 type Value = GeneratedField;
12376
12377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12378 write!(formatter, "expected one of: {:?}", &FIELDS)
12379 }
12380
12381 #[allow(unused_variables)]
12382 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12383 where
12384 E: serde::de::Error,
12385 {
12386 match value {
12387 "tables" => Ok(GeneratedField::Tables),
12388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12389 }
12390 }
12391 }
12392 deserializer.deserialize_identifier(GeneratedVisitor)
12393 }
12394 }
12395 struct GeneratedVisitor;
12396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12397 type Value = RisectlListStateTablesResponse;
12398
12399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12400 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
12401 }
12402
12403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
12404 where
12405 V: serde::de::MapAccess<'de>,
12406 {
12407 let mut tables__ = None;
12408 while let Some(k) = map_.next_key()? {
12409 match k {
12410 GeneratedField::Tables => {
12411 if tables__.is_some() {
12412 return Err(serde::de::Error::duplicate_field("tables"));
12413 }
12414 tables__ = Some(map_.next_value()?);
12415 }
12416 }
12417 }
12418 Ok(RisectlListStateTablesResponse {
12419 tables: tables__.unwrap_or_default(),
12420 })
12421 }
12422 }
12423 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
12424 }
12425}
12426impl serde::Serialize for RisectlResumeBackfillRequest {
12427 #[allow(deprecated)]
12428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12429 where
12430 S: serde::Serializer,
12431 {
12432 use serde::ser::SerializeStruct;
12433 let mut len = 0;
12434 if self.target.is_some() {
12435 len += 1;
12436 }
12437 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillRequest", len)?;
12438 if let Some(v) = self.target.as_ref() {
12439 match v {
12440 risectl_resume_backfill_request::Target::JobId(v) => {
12441 struct_ser.serialize_field("jobId", v)?;
12442 }
12443 risectl_resume_backfill_request::Target::FragmentId(v) => {
12444 struct_ser.serialize_field("fragmentId", v)?;
12445 }
12446 }
12447 }
12448 struct_ser.end()
12449 }
12450}
12451impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillRequest {
12452 #[allow(deprecated)]
12453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12454 where
12455 D: serde::Deserializer<'de>,
12456 {
12457 const FIELDS: &[&str] = &[
12458 "job_id",
12459 "jobId",
12460 "fragment_id",
12461 "fragmentId",
12462 ];
12463
12464 #[allow(clippy::enum_variant_names)]
12465 enum GeneratedField {
12466 JobId,
12467 FragmentId,
12468 }
12469 impl<'de> serde::Deserialize<'de> for GeneratedField {
12470 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12471 where
12472 D: serde::Deserializer<'de>,
12473 {
12474 struct GeneratedVisitor;
12475
12476 impl serde::de::Visitor<'_> for GeneratedVisitor {
12477 type Value = GeneratedField;
12478
12479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12480 write!(formatter, "expected one of: {:?}", &FIELDS)
12481 }
12482
12483 #[allow(unused_variables)]
12484 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12485 where
12486 E: serde::de::Error,
12487 {
12488 match value {
12489 "jobId" | "job_id" => Ok(GeneratedField::JobId),
12490 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12491 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12492 }
12493 }
12494 }
12495 deserializer.deserialize_identifier(GeneratedVisitor)
12496 }
12497 }
12498 struct GeneratedVisitor;
12499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12500 type Value = RisectlResumeBackfillRequest;
12501
12502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12503 formatter.write_str("struct ddl_service.RisectlResumeBackfillRequest")
12504 }
12505
12506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillRequest, V::Error>
12507 where
12508 V: serde::de::MapAccess<'de>,
12509 {
12510 let mut target__ = None;
12511 while let Some(k) = map_.next_key()? {
12512 match k {
12513 GeneratedField::JobId => {
12514 if target__.is_some() {
12515 return Err(serde::de::Error::duplicate_field("jobId"));
12516 }
12517 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::JobId(x.0));
12518 }
12519 GeneratedField::FragmentId => {
12520 if target__.is_some() {
12521 return Err(serde::de::Error::duplicate_field("fragmentId"));
12522 }
12523 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::FragmentId(x.0));
12524 }
12525 }
12526 }
12527 Ok(RisectlResumeBackfillRequest {
12528 target: target__,
12529 })
12530 }
12531 }
12532 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillRequest", FIELDS, GeneratedVisitor)
12533 }
12534}
12535impl serde::Serialize for RisectlResumeBackfillResponse {
12536 #[allow(deprecated)]
12537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12538 where
12539 S: serde::Serializer,
12540 {
12541 use serde::ser::SerializeStruct;
12542 let len = 0;
12543 let struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillResponse", len)?;
12544 struct_ser.end()
12545 }
12546}
12547impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillResponse {
12548 #[allow(deprecated)]
12549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12550 where
12551 D: serde::Deserializer<'de>,
12552 {
12553 const FIELDS: &[&str] = &[
12554 ];
12555
12556 #[allow(clippy::enum_variant_names)]
12557 enum GeneratedField {
12558 }
12559 impl<'de> serde::Deserialize<'de> for GeneratedField {
12560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12561 where
12562 D: serde::Deserializer<'de>,
12563 {
12564 struct GeneratedVisitor;
12565
12566 impl serde::de::Visitor<'_> for GeneratedVisitor {
12567 type Value = GeneratedField;
12568
12569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12570 write!(formatter, "expected one of: {:?}", &FIELDS)
12571 }
12572
12573 #[allow(unused_variables)]
12574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12575 where
12576 E: serde::de::Error,
12577 {
12578 Err(serde::de::Error::unknown_field(value, FIELDS))
12579 }
12580 }
12581 deserializer.deserialize_identifier(GeneratedVisitor)
12582 }
12583 }
12584 struct GeneratedVisitor;
12585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12586 type Value = RisectlResumeBackfillResponse;
12587
12588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12589 formatter.write_str("struct ddl_service.RisectlResumeBackfillResponse")
12590 }
12591
12592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillResponse, V::Error>
12593 where
12594 V: serde::de::MapAccess<'de>,
12595 {
12596 while map_.next_key::<GeneratedField>()?.is_some() {
12597 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12598 }
12599 Ok(RisectlResumeBackfillResponse {
12600 })
12601 }
12602 }
12603 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillResponse", FIELDS, GeneratedVisitor)
12604 }
12605}
12606impl serde::Serialize for SchemaChangeEnvelope {
12607 #[allow(deprecated)]
12608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12609 where
12610 S: serde::Serializer,
12611 {
12612 use serde::ser::SerializeStruct;
12613 let mut len = 0;
12614 if !self.table_changes.is_empty() {
12615 len += 1;
12616 }
12617 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
12618 if !self.table_changes.is_empty() {
12619 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
12620 }
12621 struct_ser.end()
12622 }
12623}
12624impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
12625 #[allow(deprecated)]
12626 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12627 where
12628 D: serde::Deserializer<'de>,
12629 {
12630 const FIELDS: &[&str] = &[
12631 "table_changes",
12632 "tableChanges",
12633 ];
12634
12635 #[allow(clippy::enum_variant_names)]
12636 enum GeneratedField {
12637 TableChanges,
12638 }
12639 impl<'de> serde::Deserialize<'de> for GeneratedField {
12640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12641 where
12642 D: serde::Deserializer<'de>,
12643 {
12644 struct GeneratedVisitor;
12645
12646 impl serde::de::Visitor<'_> for GeneratedVisitor {
12647 type Value = GeneratedField;
12648
12649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12650 write!(formatter, "expected one of: {:?}", &FIELDS)
12651 }
12652
12653 #[allow(unused_variables)]
12654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12655 where
12656 E: serde::de::Error,
12657 {
12658 match value {
12659 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
12660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12661 }
12662 }
12663 }
12664 deserializer.deserialize_identifier(GeneratedVisitor)
12665 }
12666 }
12667 struct GeneratedVisitor;
12668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12669 type Value = SchemaChangeEnvelope;
12670
12671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12672 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
12673 }
12674
12675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
12676 where
12677 V: serde::de::MapAccess<'de>,
12678 {
12679 let mut table_changes__ = None;
12680 while let Some(k) = map_.next_key()? {
12681 match k {
12682 GeneratedField::TableChanges => {
12683 if table_changes__.is_some() {
12684 return Err(serde::de::Error::duplicate_field("tableChanges"));
12685 }
12686 table_changes__ = Some(map_.next_value()?);
12687 }
12688 }
12689 }
12690 Ok(SchemaChangeEnvelope {
12691 table_changes: table_changes__.unwrap_or_default(),
12692 })
12693 }
12694 }
12695 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
12696 }
12697}
12698impl serde::Serialize for StreamingJobResourceType {
12699 #[allow(deprecated)]
12700 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12701 where
12702 S: serde::Serializer,
12703 {
12704 use serde::ser::SerializeStruct;
12705 let mut len = 0;
12706 if self.resource_type.is_some() {
12707 len += 1;
12708 }
12709 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
12710 if let Some(v) = self.resource_type.as_ref() {
12711 match v {
12712 streaming_job_resource_type::ResourceType::Regular(v) => {
12713 struct_ser.serialize_field("regular", v)?;
12714 }
12715 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
12716 struct_ser.serialize_field("specificResourceGroup", v)?;
12717 }
12718 streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup(v) => {
12719 struct_ser.serialize_field("serverlessBackfillResourceGroup", v)?;
12720 }
12721 }
12722 }
12723 struct_ser.end()
12724 }
12725}
12726impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
12727 #[allow(deprecated)]
12728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12729 where
12730 D: serde::Deserializer<'de>,
12731 {
12732 const FIELDS: &[&str] = &[
12733 "regular",
12734 "specific_resource_group",
12735 "specificResourceGroup",
12736 "serverless_backfill_resource_group",
12737 "serverlessBackfillResourceGroup",
12738 ];
12739
12740 #[allow(clippy::enum_variant_names)]
12741 enum GeneratedField {
12742 Regular,
12743 SpecificResourceGroup,
12744 ServerlessBackfillResourceGroup,
12745 }
12746 impl<'de> serde::Deserialize<'de> for GeneratedField {
12747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12748 where
12749 D: serde::Deserializer<'de>,
12750 {
12751 struct GeneratedVisitor;
12752
12753 impl serde::de::Visitor<'_> for GeneratedVisitor {
12754 type Value = GeneratedField;
12755
12756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12757 write!(formatter, "expected one of: {:?}", &FIELDS)
12758 }
12759
12760 #[allow(unused_variables)]
12761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12762 where
12763 E: serde::de::Error,
12764 {
12765 match value {
12766 "regular" => Ok(GeneratedField::Regular),
12767 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
12768 "serverlessBackfillResourceGroup" | "serverless_backfill_resource_group" => Ok(GeneratedField::ServerlessBackfillResourceGroup),
12769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12770 }
12771 }
12772 }
12773 deserializer.deserialize_identifier(GeneratedVisitor)
12774 }
12775 }
12776 struct GeneratedVisitor;
12777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12778 type Value = StreamingJobResourceType;
12779
12780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12781 formatter.write_str("struct ddl_service.StreamingJobResourceType")
12782 }
12783
12784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
12785 where
12786 V: serde::de::MapAccess<'de>,
12787 {
12788 let mut resource_type__ = None;
12789 while let Some(k) = map_.next_key()? {
12790 match k {
12791 GeneratedField::Regular => {
12792 if resource_type__.is_some() {
12793 return Err(serde::de::Error::duplicate_field("regular"));
12794 }
12795 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
12796 }
12797 GeneratedField::SpecificResourceGroup => {
12798 if resource_type__.is_some() {
12799 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
12800 }
12801 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
12802 }
12803 GeneratedField::ServerlessBackfillResourceGroup => {
12804 if resource_type__.is_some() {
12805 return Err(serde::de::Error::duplicate_field("serverlessBackfillResourceGroup"));
12806 }
12807 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup);
12808 }
12809 }
12810 }
12811 Ok(StreamingJobResourceType {
12812 resource_type: resource_type__,
12813 })
12814 }
12815 }
12816 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
12817 }
12818}
12819impl serde::Serialize for TableJobType {
12820 #[allow(deprecated)]
12821 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12822 where
12823 S: serde::Serializer,
12824 {
12825 let variant = match self {
12826 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
12827 Self::General => "TABLE_JOB_TYPE_GENERAL",
12828 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12829 };
12830 serializer.serialize_str(variant)
12831 }
12832}
12833impl<'de> serde::Deserialize<'de> for TableJobType {
12834 #[allow(deprecated)]
12835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12836 where
12837 D: serde::Deserializer<'de>,
12838 {
12839 const FIELDS: &[&str] = &[
12840 "TABLE_JOB_TYPE_UNSPECIFIED",
12841 "TABLE_JOB_TYPE_GENERAL",
12842 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12843 ];
12844
12845 struct GeneratedVisitor;
12846
12847 impl serde::de::Visitor<'_> for GeneratedVisitor {
12848 type Value = TableJobType;
12849
12850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12851 write!(formatter, "expected one of: {:?}", &FIELDS)
12852 }
12853
12854 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12855 where
12856 E: serde::de::Error,
12857 {
12858 i32::try_from(v)
12859 .ok()
12860 .and_then(|x| x.try_into().ok())
12861 .ok_or_else(|| {
12862 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12863 })
12864 }
12865
12866 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12867 where
12868 E: serde::de::Error,
12869 {
12870 i32::try_from(v)
12871 .ok()
12872 .and_then(|x| x.try_into().ok())
12873 .ok_or_else(|| {
12874 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12875 })
12876 }
12877
12878 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12879 where
12880 E: serde::de::Error,
12881 {
12882 match value {
12883 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
12884 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
12885 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
12886 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12887 }
12888 }
12889 }
12890 deserializer.deserialize_any(GeneratedVisitor)
12891 }
12892}
12893impl serde::Serialize for TableSchemaChange {
12894 #[allow(deprecated)]
12895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12896 where
12897 S: serde::Serializer,
12898 {
12899 use serde::ser::SerializeStruct;
12900 let mut len = 0;
12901 if self.change_type != 0 {
12902 len += 1;
12903 }
12904 if !self.cdc_table_id.is_empty() {
12905 len += 1;
12906 }
12907 if !self.columns.is_empty() {
12908 len += 1;
12909 }
12910 if !self.upstream_ddl.is_empty() {
12911 len += 1;
12912 }
12913 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
12914 if self.change_type != 0 {
12915 let v = table_schema_change::TableChangeType::try_from(self.change_type)
12916 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
12917 struct_ser.serialize_field("changeType", &v)?;
12918 }
12919 if !self.cdc_table_id.is_empty() {
12920 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
12921 }
12922 if !self.columns.is_empty() {
12923 struct_ser.serialize_field("columns", &self.columns)?;
12924 }
12925 if !self.upstream_ddl.is_empty() {
12926 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
12927 }
12928 struct_ser.end()
12929 }
12930}
12931impl<'de> serde::Deserialize<'de> for TableSchemaChange {
12932 #[allow(deprecated)]
12933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12934 where
12935 D: serde::Deserializer<'de>,
12936 {
12937 const FIELDS: &[&str] = &[
12938 "change_type",
12939 "changeType",
12940 "cdc_table_id",
12941 "cdcTableId",
12942 "columns",
12943 "upstream_ddl",
12944 "upstreamDdl",
12945 ];
12946
12947 #[allow(clippy::enum_variant_names)]
12948 enum GeneratedField {
12949 ChangeType,
12950 CdcTableId,
12951 Columns,
12952 UpstreamDdl,
12953 }
12954 impl<'de> serde::Deserialize<'de> for GeneratedField {
12955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12956 where
12957 D: serde::Deserializer<'de>,
12958 {
12959 struct GeneratedVisitor;
12960
12961 impl serde::de::Visitor<'_> for GeneratedVisitor {
12962 type Value = GeneratedField;
12963
12964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12965 write!(formatter, "expected one of: {:?}", &FIELDS)
12966 }
12967
12968 #[allow(unused_variables)]
12969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12970 where
12971 E: serde::de::Error,
12972 {
12973 match value {
12974 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
12975 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
12976 "columns" => Ok(GeneratedField::Columns),
12977 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
12978 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12979 }
12980 }
12981 }
12982 deserializer.deserialize_identifier(GeneratedVisitor)
12983 }
12984 }
12985 struct GeneratedVisitor;
12986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12987 type Value = TableSchemaChange;
12988
12989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12990 formatter.write_str("struct ddl_service.TableSchemaChange")
12991 }
12992
12993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
12994 where
12995 V: serde::de::MapAccess<'de>,
12996 {
12997 let mut change_type__ = None;
12998 let mut cdc_table_id__ = None;
12999 let mut columns__ = None;
13000 let mut upstream_ddl__ = None;
13001 while let Some(k) = map_.next_key()? {
13002 match k {
13003 GeneratedField::ChangeType => {
13004 if change_type__.is_some() {
13005 return Err(serde::de::Error::duplicate_field("changeType"));
13006 }
13007 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
13008 }
13009 GeneratedField::CdcTableId => {
13010 if cdc_table_id__.is_some() {
13011 return Err(serde::de::Error::duplicate_field("cdcTableId"));
13012 }
13013 cdc_table_id__ = Some(map_.next_value()?);
13014 }
13015 GeneratedField::Columns => {
13016 if columns__.is_some() {
13017 return Err(serde::de::Error::duplicate_field("columns"));
13018 }
13019 columns__ = Some(map_.next_value()?);
13020 }
13021 GeneratedField::UpstreamDdl => {
13022 if upstream_ddl__.is_some() {
13023 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
13024 }
13025 upstream_ddl__ = Some(map_.next_value()?);
13026 }
13027 }
13028 }
13029 Ok(TableSchemaChange {
13030 change_type: change_type__.unwrap_or_default(),
13031 cdc_table_id: cdc_table_id__.unwrap_or_default(),
13032 columns: columns__.unwrap_or_default(),
13033 upstream_ddl: upstream_ddl__.unwrap_or_default(),
13034 })
13035 }
13036 }
13037 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
13038 }
13039}
13040impl serde::Serialize for table_schema_change::TableChangeType {
13041 #[allow(deprecated)]
13042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13043 where
13044 S: serde::Serializer,
13045 {
13046 let variant = match self {
13047 Self::Unspecified => "UNSPECIFIED",
13048 Self::Alter => "ALTER",
13049 Self::Create => "CREATE",
13050 Self::Drop => "DROP",
13051 };
13052 serializer.serialize_str(variant)
13053 }
13054}
13055impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
13056 #[allow(deprecated)]
13057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13058 where
13059 D: serde::Deserializer<'de>,
13060 {
13061 const FIELDS: &[&str] = &[
13062 "UNSPECIFIED",
13063 "ALTER",
13064 "CREATE",
13065 "DROP",
13066 ];
13067
13068 struct GeneratedVisitor;
13069
13070 impl serde::de::Visitor<'_> for GeneratedVisitor {
13071 type Value = table_schema_change::TableChangeType;
13072
13073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13074 write!(formatter, "expected one of: {:?}", &FIELDS)
13075 }
13076
13077 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13078 where
13079 E: serde::de::Error,
13080 {
13081 i32::try_from(v)
13082 .ok()
13083 .and_then(|x| x.try_into().ok())
13084 .ok_or_else(|| {
13085 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13086 })
13087 }
13088
13089 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13090 where
13091 E: serde::de::Error,
13092 {
13093 i32::try_from(v)
13094 .ok()
13095 .and_then(|x| x.try_into().ok())
13096 .ok_or_else(|| {
13097 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13098 })
13099 }
13100
13101 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13102 where
13103 E: serde::de::Error,
13104 {
13105 match value {
13106 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
13107 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
13108 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
13109 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
13110 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13111 }
13112 }
13113 }
13114 deserializer.deserialize_any(GeneratedVisitor)
13115 }
13116}
13117impl serde::Serialize for WaitRequest {
13118 #[allow(deprecated)]
13119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13120 where
13121 S: serde::Serializer,
13122 {
13123 use serde::ser::SerializeStruct;
13124 let mut len = 0;
13125 if self.job_id.is_some() {
13126 len += 1;
13127 }
13128 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
13129 if let Some(v) = self.job_id.as_ref() {
13130 struct_ser.serialize_field("jobId", v)?;
13131 }
13132 struct_ser.end()
13133 }
13134}
13135impl<'de> serde::Deserialize<'de> for WaitRequest {
13136 #[allow(deprecated)]
13137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13138 where
13139 D: serde::Deserializer<'de>,
13140 {
13141 const FIELDS: &[&str] = &[
13142 "job_id",
13143 "jobId",
13144 ];
13145
13146 #[allow(clippy::enum_variant_names)]
13147 enum GeneratedField {
13148 JobId,
13149 }
13150 impl<'de> serde::Deserialize<'de> for GeneratedField {
13151 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13152 where
13153 D: serde::Deserializer<'de>,
13154 {
13155 struct GeneratedVisitor;
13156
13157 impl serde::de::Visitor<'_> for GeneratedVisitor {
13158 type Value = GeneratedField;
13159
13160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13161 write!(formatter, "expected one of: {:?}", &FIELDS)
13162 }
13163
13164 #[allow(unused_variables)]
13165 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13166 where
13167 E: serde::de::Error,
13168 {
13169 match value {
13170 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13172 }
13173 }
13174 }
13175 deserializer.deserialize_identifier(GeneratedVisitor)
13176 }
13177 }
13178 struct GeneratedVisitor;
13179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13180 type Value = WaitRequest;
13181
13182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13183 formatter.write_str("struct ddl_service.WaitRequest")
13184 }
13185
13186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
13187 where
13188 V: serde::de::MapAccess<'de>,
13189 {
13190 let mut job_id__ = None;
13191 while let Some(k) = map_.next_key()? {
13192 match k {
13193 GeneratedField::JobId => {
13194 if job_id__.is_some() {
13195 return Err(serde::de::Error::duplicate_field("jobId"));
13196 }
13197 job_id__ =
13198 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13199 ;
13200 }
13201 }
13202 }
13203 Ok(WaitRequest {
13204 job_id: job_id__,
13205 })
13206 }
13207 }
13208 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
13209 }
13210}
13211impl serde::Serialize for WaitResponse {
13212 #[allow(deprecated)]
13213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13214 where
13215 S: serde::Serializer,
13216 {
13217 use serde::ser::SerializeStruct;
13218 let mut len = 0;
13219 if self.version.is_some() {
13220 len += 1;
13221 }
13222 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
13223 if let Some(v) = self.version.as_ref() {
13224 struct_ser.serialize_field("version", v)?;
13225 }
13226 struct_ser.end()
13227 }
13228}
13229impl<'de> serde::Deserialize<'de> for WaitResponse {
13230 #[allow(deprecated)]
13231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13232 where
13233 D: serde::Deserializer<'de>,
13234 {
13235 const FIELDS: &[&str] = &[
13236 "version",
13237 ];
13238
13239 #[allow(clippy::enum_variant_names)]
13240 enum GeneratedField {
13241 Version,
13242 }
13243 impl<'de> serde::Deserialize<'de> for GeneratedField {
13244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13245 where
13246 D: serde::Deserializer<'de>,
13247 {
13248 struct GeneratedVisitor;
13249
13250 impl serde::de::Visitor<'_> for GeneratedVisitor {
13251 type Value = GeneratedField;
13252
13253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13254 write!(formatter, "expected one of: {:?}", &FIELDS)
13255 }
13256
13257 #[allow(unused_variables)]
13258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13259 where
13260 E: serde::de::Error,
13261 {
13262 match value {
13263 "version" => Ok(GeneratedField::Version),
13264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13265 }
13266 }
13267 }
13268 deserializer.deserialize_identifier(GeneratedVisitor)
13269 }
13270 }
13271 struct GeneratedVisitor;
13272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13273 type Value = WaitResponse;
13274
13275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13276 formatter.write_str("struct ddl_service.WaitResponse")
13277 }
13278
13279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
13280 where
13281 V: serde::de::MapAccess<'de>,
13282 {
13283 let mut version__ = None;
13284 while let Some(k) = map_.next_key()? {
13285 match k {
13286 GeneratedField::Version => {
13287 if version__.is_some() {
13288 return Err(serde::de::Error::duplicate_field("version"));
13289 }
13290 version__ = map_.next_value()?;
13291 }
13292 }
13293 }
13294 Ok(WaitResponse {
13295 version: version__,
13296 })
13297 }
13298 }
13299 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
13300 }
13301}
13302impl serde::Serialize for WaitVersion {
13303 #[allow(deprecated)]
13304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13305 where
13306 S: serde::Serializer,
13307 {
13308 use serde::ser::SerializeStruct;
13309 let mut len = 0;
13310 if self.catalog_version != 0 {
13311 len += 1;
13312 }
13313 if self.hummock_version_id != 0 {
13314 len += 1;
13315 }
13316 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
13317 if self.catalog_version != 0 {
13318 #[allow(clippy::needless_borrow)]
13319 #[allow(clippy::needless_borrows_for_generic_args)]
13320 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13321 }
13322 if self.hummock_version_id != 0 {
13323 #[allow(clippy::needless_borrow)]
13324 #[allow(clippy::needless_borrows_for_generic_args)]
13325 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
13326 }
13327 struct_ser.end()
13328 }
13329}
13330impl<'de> serde::Deserialize<'de> for WaitVersion {
13331 #[allow(deprecated)]
13332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13333 where
13334 D: serde::Deserializer<'de>,
13335 {
13336 const FIELDS: &[&str] = &[
13337 "catalog_version",
13338 "catalogVersion",
13339 "hummock_version_id",
13340 "hummockVersionId",
13341 ];
13342
13343 #[allow(clippy::enum_variant_names)]
13344 enum GeneratedField {
13345 CatalogVersion,
13346 HummockVersionId,
13347 }
13348 impl<'de> serde::Deserialize<'de> for GeneratedField {
13349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13350 where
13351 D: serde::Deserializer<'de>,
13352 {
13353 struct GeneratedVisitor;
13354
13355 impl serde::de::Visitor<'_> for GeneratedVisitor {
13356 type Value = GeneratedField;
13357
13358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13359 write!(formatter, "expected one of: {:?}", &FIELDS)
13360 }
13361
13362 #[allow(unused_variables)]
13363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13364 where
13365 E: serde::de::Error,
13366 {
13367 match value {
13368 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13369 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
13370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13371 }
13372 }
13373 }
13374 deserializer.deserialize_identifier(GeneratedVisitor)
13375 }
13376 }
13377 struct GeneratedVisitor;
13378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13379 type Value = WaitVersion;
13380
13381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13382 formatter.write_str("struct ddl_service.WaitVersion")
13383 }
13384
13385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
13386 where
13387 V: serde::de::MapAccess<'de>,
13388 {
13389 let mut catalog_version__ = None;
13390 let mut hummock_version_id__ = None;
13391 while let Some(k) = map_.next_key()? {
13392 match k {
13393 GeneratedField::CatalogVersion => {
13394 if catalog_version__.is_some() {
13395 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13396 }
13397 catalog_version__ =
13398 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13399 ;
13400 }
13401 GeneratedField::HummockVersionId => {
13402 if hummock_version_id__.is_some() {
13403 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
13404 }
13405 hummock_version_id__ =
13406 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13407 ;
13408 }
13409 }
13410 }
13411 Ok(WaitVersion {
13412 catalog_version: catalog_version__.unwrap_or_default(),
13413 hummock_version_id: hummock_version_id__.unwrap_or_default(),
13414 })
13415 }
13416 }
13417 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
13418 }
13419}