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 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismRequest", len)?;
21 if self.table_id != 0 {
22 struct_ser.serialize_field("tableId", &self.table_id)?;
23 }
24 if let Some(v) = self.parallelism.as_ref() {
25 struct_ser.serialize_field("parallelism", v)?;
26 }
27 if self.deferred {
28 struct_ser.serialize_field("deferred", &self.deferred)?;
29 }
30 struct_ser.end()
31 }
32}
33impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismRequest {
34 #[allow(deprecated)]
35 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
36 where
37 D: serde::Deserializer<'de>,
38 {
39 const FIELDS: &[&str] = &[
40 "table_id",
41 "tableId",
42 "parallelism",
43 "deferred",
44 ];
45
46 #[allow(clippy::enum_variant_names)]
47 enum GeneratedField {
48 TableId,
49 Parallelism,
50 Deferred,
51 }
52 impl<'de> serde::Deserialize<'de> for GeneratedField {
53 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
54 where
55 D: serde::Deserializer<'de>,
56 {
57 struct GeneratedVisitor;
58
59 impl serde::de::Visitor<'_> for GeneratedVisitor {
60 type Value = GeneratedField;
61
62 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
63 write!(formatter, "expected one of: {:?}", &FIELDS)
64 }
65
66 #[allow(unused_variables)]
67 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
68 where
69 E: serde::de::Error,
70 {
71 match value {
72 "tableId" | "table_id" => Ok(GeneratedField::TableId),
73 "parallelism" => Ok(GeneratedField::Parallelism),
74 "deferred" => Ok(GeneratedField::Deferred),
75 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
76 }
77 }
78 }
79 deserializer.deserialize_identifier(GeneratedVisitor)
80 }
81 }
82 struct GeneratedVisitor;
83 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
84 type Value = AlterBackfillParallelismRequest;
85
86 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
87 formatter.write_str("struct ddl_service.AlterBackfillParallelismRequest")
88 }
89
90 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismRequest, V::Error>
91 where
92 V: serde::de::MapAccess<'de>,
93 {
94 let mut table_id__ = None;
95 let mut parallelism__ = None;
96 let mut deferred__ = None;
97 while let Some(k) = map_.next_key()? {
98 match k {
99 GeneratedField::TableId => {
100 if table_id__.is_some() {
101 return Err(serde::de::Error::duplicate_field("tableId"));
102 }
103 table_id__ =
104 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
105 ;
106 }
107 GeneratedField::Parallelism => {
108 if parallelism__.is_some() {
109 return Err(serde::de::Error::duplicate_field("parallelism"));
110 }
111 parallelism__ = map_.next_value()?;
112 }
113 GeneratedField::Deferred => {
114 if deferred__.is_some() {
115 return Err(serde::de::Error::duplicate_field("deferred"));
116 }
117 deferred__ = Some(map_.next_value()?);
118 }
119 }
120 }
121 Ok(AlterBackfillParallelismRequest {
122 table_id: table_id__.unwrap_or_default(),
123 parallelism: parallelism__,
124 deferred: deferred__.unwrap_or_default(),
125 })
126 }
127 }
128 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismRequest", FIELDS, GeneratedVisitor)
129 }
130}
131impl serde::Serialize for AlterBackfillParallelismResponse {
132 #[allow(deprecated)]
133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
134 where
135 S: serde::Serializer,
136 {
137 use serde::ser::SerializeStruct;
138 let len = 0;
139 let struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismResponse", len)?;
140 struct_ser.end()
141 }
142}
143impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismResponse {
144 #[allow(deprecated)]
145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
146 where
147 D: serde::Deserializer<'de>,
148 {
149 const FIELDS: &[&str] = &[
150 ];
151
152 #[allow(clippy::enum_variant_names)]
153 enum GeneratedField {
154 }
155 impl<'de> serde::Deserialize<'de> for GeneratedField {
156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
157 where
158 D: serde::Deserializer<'de>,
159 {
160 struct GeneratedVisitor;
161
162 impl serde::de::Visitor<'_> for GeneratedVisitor {
163 type Value = GeneratedField;
164
165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166 write!(formatter, "expected one of: {:?}", &FIELDS)
167 }
168
169 #[allow(unused_variables)]
170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
171 where
172 E: serde::de::Error,
173 {
174 Err(serde::de::Error::unknown_field(value, FIELDS))
175 }
176 }
177 deserializer.deserialize_identifier(GeneratedVisitor)
178 }
179 }
180 struct GeneratedVisitor;
181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
182 type Value = AlterBackfillParallelismResponse;
183
184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
185 formatter.write_str("struct ddl_service.AlterBackfillParallelismResponse")
186 }
187
188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismResponse, V::Error>
189 where
190 V: serde::de::MapAccess<'de>,
191 {
192 while map_.next_key::<GeneratedField>()?.is_some() {
193 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
194 }
195 Ok(AlterBackfillParallelismResponse {
196 })
197 }
198 }
199 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismResponse", FIELDS, GeneratedVisitor)
200 }
201}
202impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
203 #[allow(deprecated)]
204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
205 where
206 S: serde::Serializer,
207 {
208 use serde::ser::SerializeStruct;
209 let mut len = 0;
210 if self.table_id != 0 {
211 len += 1;
212 }
213 if self.parallelism.is_some() {
214 len += 1;
215 }
216 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
217 if self.table_id != 0 {
218 struct_ser.serialize_field("tableId", &self.table_id)?;
219 }
220 if let Some(v) = self.parallelism.as_ref() {
221 struct_ser.serialize_field("parallelism", v)?;
222 }
223 struct_ser.end()
224 }
225}
226impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
227 #[allow(deprecated)]
228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
229 where
230 D: serde::Deserializer<'de>,
231 {
232 const FIELDS: &[&str] = &[
233 "table_id",
234 "tableId",
235 "parallelism",
236 ];
237
238 #[allow(clippy::enum_variant_names)]
239 enum GeneratedField {
240 TableId,
241 Parallelism,
242 }
243 impl<'de> serde::Deserialize<'de> for GeneratedField {
244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
245 where
246 D: serde::Deserializer<'de>,
247 {
248 struct GeneratedVisitor;
249
250 impl serde::de::Visitor<'_> for GeneratedVisitor {
251 type Value = GeneratedField;
252
253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
254 write!(formatter, "expected one of: {:?}", &FIELDS)
255 }
256
257 #[allow(unused_variables)]
258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
259 where
260 E: serde::de::Error,
261 {
262 match value {
263 "tableId" | "table_id" => Ok(GeneratedField::TableId),
264 "parallelism" => Ok(GeneratedField::Parallelism),
265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
266 }
267 }
268 }
269 deserializer.deserialize_identifier(GeneratedVisitor)
270 }
271 }
272 struct GeneratedVisitor;
273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
274 type Value = AlterCdcTableBackfillParallelismRequest;
275
276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
277 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
278 }
279
280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
281 where
282 V: serde::de::MapAccess<'de>,
283 {
284 let mut table_id__ = None;
285 let mut parallelism__ = None;
286 while let Some(k) = map_.next_key()? {
287 match k {
288 GeneratedField::TableId => {
289 if table_id__.is_some() {
290 return Err(serde::de::Error::duplicate_field("tableId"));
291 }
292 table_id__ =
293 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
294 ;
295 }
296 GeneratedField::Parallelism => {
297 if parallelism__.is_some() {
298 return Err(serde::de::Error::duplicate_field("parallelism"));
299 }
300 parallelism__ = map_.next_value()?;
301 }
302 }
303 }
304 Ok(AlterCdcTableBackfillParallelismRequest {
305 table_id: table_id__.unwrap_or_default(),
306 parallelism: parallelism__,
307 })
308 }
309 }
310 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
311 }
312}
313impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
314 #[allow(deprecated)]
315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
316 where
317 S: serde::Serializer,
318 {
319 use serde::ser::SerializeStruct;
320 let len = 0;
321 let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
322 struct_ser.end()
323 }
324}
325impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
326 #[allow(deprecated)]
327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
328 where
329 D: serde::Deserializer<'de>,
330 {
331 const FIELDS: &[&str] = &[
332 ];
333
334 #[allow(clippy::enum_variant_names)]
335 enum GeneratedField {
336 }
337 impl<'de> serde::Deserialize<'de> for GeneratedField {
338 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
339 where
340 D: serde::Deserializer<'de>,
341 {
342 struct GeneratedVisitor;
343
344 impl serde::de::Visitor<'_> for GeneratedVisitor {
345 type Value = GeneratedField;
346
347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
348 write!(formatter, "expected one of: {:?}", &FIELDS)
349 }
350
351 #[allow(unused_variables)]
352 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
353 where
354 E: serde::de::Error,
355 {
356 Err(serde::de::Error::unknown_field(value, FIELDS))
357 }
358 }
359 deserializer.deserialize_identifier(GeneratedVisitor)
360 }
361 }
362 struct GeneratedVisitor;
363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
364 type Value = AlterCdcTableBackfillParallelismResponse;
365
366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
367 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
368 }
369
370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
371 where
372 V: serde::de::MapAccess<'de>,
373 {
374 while map_.next_key::<GeneratedField>()?.is_some() {
375 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
376 }
377 Ok(AlterCdcTableBackfillParallelismResponse {
378 })
379 }
380 }
381 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
382 }
383}
384impl serde::Serialize for AlterDatabaseParamRequest {
385 #[allow(deprecated)]
386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
387 where
388 S: serde::Serializer,
389 {
390 use serde::ser::SerializeStruct;
391 let mut len = 0;
392 if self.database_id != 0 {
393 len += 1;
394 }
395 if self.param.is_some() {
396 len += 1;
397 }
398 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
399 if self.database_id != 0 {
400 struct_ser.serialize_field("databaseId", &self.database_id)?;
401 }
402 if let Some(v) = self.param.as_ref() {
403 match v {
404 alter_database_param_request::Param::BarrierIntervalMs(v) => {
405 struct_ser.serialize_field("barrierIntervalMs", v)?;
406 }
407 alter_database_param_request::Param::CheckpointFrequency(v) => {
408 struct_ser.serialize_field("checkpointFrequency", v)?;
409 }
410 }
411 }
412 struct_ser.end()
413 }
414}
415impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
416 #[allow(deprecated)]
417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
418 where
419 D: serde::Deserializer<'de>,
420 {
421 const FIELDS: &[&str] = &[
422 "database_id",
423 "databaseId",
424 "barrier_interval_ms",
425 "barrierIntervalMs",
426 "checkpoint_frequency",
427 "checkpointFrequency",
428 ];
429
430 #[allow(clippy::enum_variant_names)]
431 enum GeneratedField {
432 DatabaseId,
433 BarrierIntervalMs,
434 CheckpointFrequency,
435 }
436 impl<'de> serde::Deserialize<'de> for GeneratedField {
437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
438 where
439 D: serde::Deserializer<'de>,
440 {
441 struct GeneratedVisitor;
442
443 impl serde::de::Visitor<'_> for GeneratedVisitor {
444 type Value = GeneratedField;
445
446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
447 write!(formatter, "expected one of: {:?}", &FIELDS)
448 }
449
450 #[allow(unused_variables)]
451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
452 where
453 E: serde::de::Error,
454 {
455 match value {
456 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
457 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
458 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
459 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
460 }
461 }
462 }
463 deserializer.deserialize_identifier(GeneratedVisitor)
464 }
465 }
466 struct GeneratedVisitor;
467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
468 type Value = AlterDatabaseParamRequest;
469
470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
471 formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
472 }
473
474 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
475 where
476 V: serde::de::MapAccess<'de>,
477 {
478 let mut database_id__ = None;
479 let mut param__ = None;
480 while let Some(k) = map_.next_key()? {
481 match k {
482 GeneratedField::DatabaseId => {
483 if database_id__.is_some() {
484 return Err(serde::de::Error::duplicate_field("databaseId"));
485 }
486 database_id__ =
487 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
488 ;
489 }
490 GeneratedField::BarrierIntervalMs => {
491 if param__.is_some() {
492 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
493 }
494 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
495;
496 }
497 GeneratedField::CheckpointFrequency => {
498 if param__.is_some() {
499 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
500 }
501 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
502;
503 }
504 }
505 }
506 Ok(AlterDatabaseParamRequest {
507 database_id: database_id__.unwrap_or_default(),
508 param: param__,
509 })
510 }
511 }
512 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
513 }
514}
515impl serde::Serialize for AlterDatabaseParamResponse {
516 #[allow(deprecated)]
517 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
518 where
519 S: serde::Serializer,
520 {
521 use serde::ser::SerializeStruct;
522 let mut len = 0;
523 if self.status.is_some() {
524 len += 1;
525 }
526 if self.version.is_some() {
527 len += 1;
528 }
529 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
530 if let Some(v) = self.status.as_ref() {
531 struct_ser.serialize_field("status", v)?;
532 }
533 if let Some(v) = self.version.as_ref() {
534 struct_ser.serialize_field("version", v)?;
535 }
536 struct_ser.end()
537 }
538}
539impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
540 #[allow(deprecated)]
541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
542 where
543 D: serde::Deserializer<'de>,
544 {
545 const FIELDS: &[&str] = &[
546 "status",
547 "version",
548 ];
549
550 #[allow(clippy::enum_variant_names)]
551 enum GeneratedField {
552 Status,
553 Version,
554 }
555 impl<'de> serde::Deserialize<'de> for GeneratedField {
556 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
557 where
558 D: serde::Deserializer<'de>,
559 {
560 struct GeneratedVisitor;
561
562 impl serde::de::Visitor<'_> for GeneratedVisitor {
563 type Value = GeneratedField;
564
565 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
566 write!(formatter, "expected one of: {:?}", &FIELDS)
567 }
568
569 #[allow(unused_variables)]
570 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
571 where
572 E: serde::de::Error,
573 {
574 match value {
575 "status" => Ok(GeneratedField::Status),
576 "version" => Ok(GeneratedField::Version),
577 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
578 }
579 }
580 }
581 deserializer.deserialize_identifier(GeneratedVisitor)
582 }
583 }
584 struct GeneratedVisitor;
585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
586 type Value = AlterDatabaseParamResponse;
587
588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
589 formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
590 }
591
592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
593 where
594 V: serde::de::MapAccess<'de>,
595 {
596 let mut status__ = None;
597 let mut version__ = None;
598 while let Some(k) = map_.next_key()? {
599 match k {
600 GeneratedField::Status => {
601 if status__.is_some() {
602 return Err(serde::de::Error::duplicate_field("status"));
603 }
604 status__ = map_.next_value()?;
605 }
606 GeneratedField::Version => {
607 if version__.is_some() {
608 return Err(serde::de::Error::duplicate_field("version"));
609 }
610 version__ = map_.next_value()?;
611 }
612 }
613 }
614 Ok(AlterDatabaseParamResponse {
615 status: status__,
616 version: version__,
617 })
618 }
619 }
620 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
621 }
622}
623impl serde::Serialize for AlterFragmentParallelismRequest {
624 #[allow(deprecated)]
625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
626 where
627 S: serde::Serializer,
628 {
629 use serde::ser::SerializeStruct;
630 let mut len = 0;
631 if !self.fragment_ids.is_empty() {
632 len += 1;
633 }
634 if self.parallelism.is_some() {
635 len += 1;
636 }
637 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismRequest", len)?;
638 if !self.fragment_ids.is_empty() {
639 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
640 }
641 if let Some(v) = self.parallelism.as_ref() {
642 struct_ser.serialize_field("parallelism", v)?;
643 }
644 struct_ser.end()
645 }
646}
647impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismRequest {
648 #[allow(deprecated)]
649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
650 where
651 D: serde::Deserializer<'de>,
652 {
653 const FIELDS: &[&str] = &[
654 "fragment_ids",
655 "fragmentIds",
656 "parallelism",
657 ];
658
659 #[allow(clippy::enum_variant_names)]
660 enum GeneratedField {
661 FragmentIds,
662 Parallelism,
663 }
664 impl<'de> serde::Deserialize<'de> for GeneratedField {
665 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
666 where
667 D: serde::Deserializer<'de>,
668 {
669 struct GeneratedVisitor;
670
671 impl serde::de::Visitor<'_> for GeneratedVisitor {
672 type Value = GeneratedField;
673
674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
675 write!(formatter, "expected one of: {:?}", &FIELDS)
676 }
677
678 #[allow(unused_variables)]
679 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
680 where
681 E: serde::de::Error,
682 {
683 match value {
684 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
685 "parallelism" => Ok(GeneratedField::Parallelism),
686 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
687 }
688 }
689 }
690 deserializer.deserialize_identifier(GeneratedVisitor)
691 }
692 }
693 struct GeneratedVisitor;
694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
695 type Value = AlterFragmentParallelismRequest;
696
697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
698 formatter.write_str("struct ddl_service.AlterFragmentParallelismRequest")
699 }
700
701 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismRequest, V::Error>
702 where
703 V: serde::de::MapAccess<'de>,
704 {
705 let mut fragment_ids__ = None;
706 let mut parallelism__ = None;
707 while let Some(k) = map_.next_key()? {
708 match k {
709 GeneratedField::FragmentIds => {
710 if fragment_ids__.is_some() {
711 return Err(serde::de::Error::duplicate_field("fragmentIds"));
712 }
713 fragment_ids__ =
714 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
715 .into_iter().map(|x| x.0).collect())
716 ;
717 }
718 GeneratedField::Parallelism => {
719 if parallelism__.is_some() {
720 return Err(serde::de::Error::duplicate_field("parallelism"));
721 }
722 parallelism__ = map_.next_value()?;
723 }
724 }
725 }
726 Ok(AlterFragmentParallelismRequest {
727 fragment_ids: fragment_ids__.unwrap_or_default(),
728 parallelism: parallelism__,
729 })
730 }
731 }
732 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismRequest", FIELDS, GeneratedVisitor)
733 }
734}
735impl serde::Serialize for AlterFragmentParallelismResponse {
736 #[allow(deprecated)]
737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
738 where
739 S: serde::Serializer,
740 {
741 use serde::ser::SerializeStruct;
742 let len = 0;
743 let struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismResponse", len)?;
744 struct_ser.end()
745 }
746}
747impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismResponse {
748 #[allow(deprecated)]
749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
750 where
751 D: serde::Deserializer<'de>,
752 {
753 const FIELDS: &[&str] = &[
754 ];
755
756 #[allow(clippy::enum_variant_names)]
757 enum GeneratedField {
758 }
759 impl<'de> serde::Deserialize<'de> for GeneratedField {
760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
761 where
762 D: serde::Deserializer<'de>,
763 {
764 struct GeneratedVisitor;
765
766 impl serde::de::Visitor<'_> for GeneratedVisitor {
767 type Value = GeneratedField;
768
769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
770 write!(formatter, "expected one of: {:?}", &FIELDS)
771 }
772
773 #[allow(unused_variables)]
774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
775 where
776 E: serde::de::Error,
777 {
778 Err(serde::de::Error::unknown_field(value, FIELDS))
779 }
780 }
781 deserializer.deserialize_identifier(GeneratedVisitor)
782 }
783 }
784 struct GeneratedVisitor;
785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
786 type Value = AlterFragmentParallelismResponse;
787
788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
789 formatter.write_str("struct ddl_service.AlterFragmentParallelismResponse")
790 }
791
792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismResponse, V::Error>
793 where
794 V: serde::de::MapAccess<'de>,
795 {
796 while map_.next_key::<GeneratedField>()?.is_some() {
797 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
798 }
799 Ok(AlterFragmentParallelismResponse {
800 })
801 }
802 }
803 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismResponse", FIELDS, GeneratedVisitor)
804 }
805}
806impl serde::Serialize for AlterNameRequest {
807 #[allow(deprecated)]
808 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
809 where
810 S: serde::Serializer,
811 {
812 use serde::ser::SerializeStruct;
813 let mut len = 0;
814 if !self.new_name.is_empty() {
815 len += 1;
816 }
817 if self.object.is_some() {
818 len += 1;
819 }
820 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
821 if !self.new_name.is_empty() {
822 struct_ser.serialize_field("newName", &self.new_name)?;
823 }
824 if let Some(v) = self.object.as_ref() {
825 match v {
826 alter_name_request::Object::TableId(v) => {
827 struct_ser.serialize_field("tableId", v)?;
828 }
829 alter_name_request::Object::ViewId(v) => {
830 struct_ser.serialize_field("viewId", v)?;
831 }
832 alter_name_request::Object::IndexId(v) => {
833 struct_ser.serialize_field("indexId", v)?;
834 }
835 alter_name_request::Object::SinkId(v) => {
836 struct_ser.serialize_field("sinkId", v)?;
837 }
838 alter_name_request::Object::SourceId(v) => {
839 struct_ser.serialize_field("sourceId", v)?;
840 }
841 alter_name_request::Object::SchemaId(v) => {
842 struct_ser.serialize_field("schemaId", v)?;
843 }
844 alter_name_request::Object::DatabaseId(v) => {
845 struct_ser.serialize_field("databaseId", v)?;
846 }
847 alter_name_request::Object::SubscriptionId(v) => {
848 struct_ser.serialize_field("subscriptionId", v)?;
849 }
850 }
851 }
852 struct_ser.end()
853 }
854}
855impl<'de> serde::Deserialize<'de> for AlterNameRequest {
856 #[allow(deprecated)]
857 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
858 where
859 D: serde::Deserializer<'de>,
860 {
861 const FIELDS: &[&str] = &[
862 "new_name",
863 "newName",
864 "table_id",
865 "tableId",
866 "view_id",
867 "viewId",
868 "index_id",
869 "indexId",
870 "sink_id",
871 "sinkId",
872 "source_id",
873 "sourceId",
874 "schema_id",
875 "schemaId",
876 "database_id",
877 "databaseId",
878 "subscription_id",
879 "subscriptionId",
880 ];
881
882 #[allow(clippy::enum_variant_names)]
883 enum GeneratedField {
884 NewName,
885 TableId,
886 ViewId,
887 IndexId,
888 SinkId,
889 SourceId,
890 SchemaId,
891 DatabaseId,
892 SubscriptionId,
893 }
894 impl<'de> serde::Deserialize<'de> for GeneratedField {
895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
896 where
897 D: serde::Deserializer<'de>,
898 {
899 struct GeneratedVisitor;
900
901 impl serde::de::Visitor<'_> for GeneratedVisitor {
902 type Value = GeneratedField;
903
904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
905 write!(formatter, "expected one of: {:?}", &FIELDS)
906 }
907
908 #[allow(unused_variables)]
909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
910 where
911 E: serde::de::Error,
912 {
913 match value {
914 "newName" | "new_name" => Ok(GeneratedField::NewName),
915 "tableId" | "table_id" => Ok(GeneratedField::TableId),
916 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
917 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
918 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
919 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
920 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
921 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
922 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
924 }
925 }
926 }
927 deserializer.deserialize_identifier(GeneratedVisitor)
928 }
929 }
930 struct GeneratedVisitor;
931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
932 type Value = AlterNameRequest;
933
934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
935 formatter.write_str("struct ddl_service.AlterNameRequest")
936 }
937
938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
939 where
940 V: serde::de::MapAccess<'de>,
941 {
942 let mut new_name__ = None;
943 let mut object__ = None;
944 while let Some(k) = map_.next_key()? {
945 match k {
946 GeneratedField::NewName => {
947 if new_name__.is_some() {
948 return Err(serde::de::Error::duplicate_field("newName"));
949 }
950 new_name__ = Some(map_.next_value()?);
951 }
952 GeneratedField::TableId => {
953 if object__.is_some() {
954 return Err(serde::de::Error::duplicate_field("tableId"));
955 }
956 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
957 }
958 GeneratedField::ViewId => {
959 if object__.is_some() {
960 return Err(serde::de::Error::duplicate_field("viewId"));
961 }
962 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
963 }
964 GeneratedField::IndexId => {
965 if object__.is_some() {
966 return Err(serde::de::Error::duplicate_field("indexId"));
967 }
968 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
969 }
970 GeneratedField::SinkId => {
971 if object__.is_some() {
972 return Err(serde::de::Error::duplicate_field("sinkId"));
973 }
974 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
975 }
976 GeneratedField::SourceId => {
977 if object__.is_some() {
978 return Err(serde::de::Error::duplicate_field("sourceId"));
979 }
980 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
981 }
982 GeneratedField::SchemaId => {
983 if object__.is_some() {
984 return Err(serde::de::Error::duplicate_field("schemaId"));
985 }
986 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
987 }
988 GeneratedField::DatabaseId => {
989 if object__.is_some() {
990 return Err(serde::de::Error::duplicate_field("databaseId"));
991 }
992 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
993 }
994 GeneratedField::SubscriptionId => {
995 if object__.is_some() {
996 return Err(serde::de::Error::duplicate_field("subscriptionId"));
997 }
998 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
999 }
1000 }
1001 }
1002 Ok(AlterNameRequest {
1003 new_name: new_name__.unwrap_or_default(),
1004 object: object__,
1005 })
1006 }
1007 }
1008 deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
1009 }
1010}
1011impl serde::Serialize for AlterNameResponse {
1012 #[allow(deprecated)]
1013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1014 where
1015 S: serde::Serializer,
1016 {
1017 use serde::ser::SerializeStruct;
1018 let mut len = 0;
1019 if self.status.is_some() {
1020 len += 1;
1021 }
1022 if self.version.is_some() {
1023 len += 1;
1024 }
1025 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
1026 if let Some(v) = self.status.as_ref() {
1027 struct_ser.serialize_field("status", v)?;
1028 }
1029 if let Some(v) = self.version.as_ref() {
1030 struct_ser.serialize_field("version", v)?;
1031 }
1032 struct_ser.end()
1033 }
1034}
1035impl<'de> serde::Deserialize<'de> for AlterNameResponse {
1036 #[allow(deprecated)]
1037 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1038 where
1039 D: serde::Deserializer<'de>,
1040 {
1041 const FIELDS: &[&str] = &[
1042 "status",
1043 "version",
1044 ];
1045
1046 #[allow(clippy::enum_variant_names)]
1047 enum GeneratedField {
1048 Status,
1049 Version,
1050 }
1051 impl<'de> serde::Deserialize<'de> for GeneratedField {
1052 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1053 where
1054 D: serde::Deserializer<'de>,
1055 {
1056 struct GeneratedVisitor;
1057
1058 impl serde::de::Visitor<'_> for GeneratedVisitor {
1059 type Value = GeneratedField;
1060
1061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1062 write!(formatter, "expected one of: {:?}", &FIELDS)
1063 }
1064
1065 #[allow(unused_variables)]
1066 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1067 where
1068 E: serde::de::Error,
1069 {
1070 match value {
1071 "status" => Ok(GeneratedField::Status),
1072 "version" => Ok(GeneratedField::Version),
1073 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1074 }
1075 }
1076 }
1077 deserializer.deserialize_identifier(GeneratedVisitor)
1078 }
1079 }
1080 struct GeneratedVisitor;
1081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1082 type Value = AlterNameResponse;
1083
1084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1085 formatter.write_str("struct ddl_service.AlterNameResponse")
1086 }
1087
1088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
1089 where
1090 V: serde::de::MapAccess<'de>,
1091 {
1092 let mut status__ = None;
1093 let mut version__ = None;
1094 while let Some(k) = map_.next_key()? {
1095 match k {
1096 GeneratedField::Status => {
1097 if status__.is_some() {
1098 return Err(serde::de::Error::duplicate_field("status"));
1099 }
1100 status__ = map_.next_value()?;
1101 }
1102 GeneratedField::Version => {
1103 if version__.is_some() {
1104 return Err(serde::de::Error::duplicate_field("version"));
1105 }
1106 version__ = map_.next_value()?;
1107 }
1108 }
1109 }
1110 Ok(AlterNameResponse {
1111 status: status__,
1112 version: version__,
1113 })
1114 }
1115 }
1116 deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
1117 }
1118}
1119impl serde::Serialize for AlterOwnerRequest {
1120 #[allow(deprecated)]
1121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1122 where
1123 S: serde::Serializer,
1124 {
1125 use serde::ser::SerializeStruct;
1126 let mut len = 0;
1127 if self.owner_id != 0 {
1128 len += 1;
1129 }
1130 if self.object.is_some() {
1131 len += 1;
1132 }
1133 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
1134 if self.owner_id != 0 {
1135 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1136 }
1137 if let Some(v) = self.object.as_ref() {
1138 match v {
1139 alter_owner_request::Object::TableId(v) => {
1140 struct_ser.serialize_field("tableId", v)?;
1141 }
1142 alter_owner_request::Object::ViewId(v) => {
1143 struct_ser.serialize_field("viewId", v)?;
1144 }
1145 alter_owner_request::Object::SourceId(v) => {
1146 struct_ser.serialize_field("sourceId", v)?;
1147 }
1148 alter_owner_request::Object::SinkId(v) => {
1149 struct_ser.serialize_field("sinkId", v)?;
1150 }
1151 alter_owner_request::Object::SchemaId(v) => {
1152 struct_ser.serialize_field("schemaId", v)?;
1153 }
1154 alter_owner_request::Object::DatabaseId(v) => {
1155 struct_ser.serialize_field("databaseId", v)?;
1156 }
1157 alter_owner_request::Object::SubscriptionId(v) => {
1158 struct_ser.serialize_field("subscriptionId", v)?;
1159 }
1160 alter_owner_request::Object::ConnectionId(v) => {
1161 struct_ser.serialize_field("connectionId", v)?;
1162 }
1163 alter_owner_request::Object::SecretId(v) => {
1164 struct_ser.serialize_field("secretId", v)?;
1165 }
1166 alter_owner_request::Object::FunctionId(v) => {
1167 struct_ser.serialize_field("functionId", v)?;
1168 }
1169 }
1170 }
1171 struct_ser.end()
1172 }
1173}
1174impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
1175 #[allow(deprecated)]
1176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1177 where
1178 D: serde::Deserializer<'de>,
1179 {
1180 const FIELDS: &[&str] = &[
1181 "owner_id",
1182 "ownerId",
1183 "table_id",
1184 "tableId",
1185 "view_id",
1186 "viewId",
1187 "source_id",
1188 "sourceId",
1189 "sink_id",
1190 "sinkId",
1191 "schema_id",
1192 "schemaId",
1193 "database_id",
1194 "databaseId",
1195 "subscription_id",
1196 "subscriptionId",
1197 "connection_id",
1198 "connectionId",
1199 "secret_id",
1200 "secretId",
1201 "function_id",
1202 "functionId",
1203 ];
1204
1205 #[allow(clippy::enum_variant_names)]
1206 enum GeneratedField {
1207 OwnerId,
1208 TableId,
1209 ViewId,
1210 SourceId,
1211 SinkId,
1212 SchemaId,
1213 DatabaseId,
1214 SubscriptionId,
1215 ConnectionId,
1216 SecretId,
1217 FunctionId,
1218 }
1219 impl<'de> serde::Deserialize<'de> for GeneratedField {
1220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1221 where
1222 D: serde::Deserializer<'de>,
1223 {
1224 struct GeneratedVisitor;
1225
1226 impl serde::de::Visitor<'_> for GeneratedVisitor {
1227 type Value = GeneratedField;
1228
1229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1230 write!(formatter, "expected one of: {:?}", &FIELDS)
1231 }
1232
1233 #[allow(unused_variables)]
1234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1235 where
1236 E: serde::de::Error,
1237 {
1238 match value {
1239 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1240 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1241 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1242 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1243 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1244 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1245 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1246 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1247 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1248 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1249 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1250 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1251 }
1252 }
1253 }
1254 deserializer.deserialize_identifier(GeneratedVisitor)
1255 }
1256 }
1257 struct GeneratedVisitor;
1258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1259 type Value = AlterOwnerRequest;
1260
1261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1262 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1263 }
1264
1265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1266 where
1267 V: serde::de::MapAccess<'de>,
1268 {
1269 let mut owner_id__ = None;
1270 let mut object__ = None;
1271 while let Some(k) = map_.next_key()? {
1272 match k {
1273 GeneratedField::OwnerId => {
1274 if owner_id__.is_some() {
1275 return Err(serde::de::Error::duplicate_field("ownerId"));
1276 }
1277 owner_id__ =
1278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1279 ;
1280 }
1281 GeneratedField::TableId => {
1282 if object__.is_some() {
1283 return Err(serde::de::Error::duplicate_field("tableId"));
1284 }
1285 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1286 }
1287 GeneratedField::ViewId => {
1288 if object__.is_some() {
1289 return Err(serde::de::Error::duplicate_field("viewId"));
1290 }
1291 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1292 }
1293 GeneratedField::SourceId => {
1294 if object__.is_some() {
1295 return Err(serde::de::Error::duplicate_field("sourceId"));
1296 }
1297 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1298 }
1299 GeneratedField::SinkId => {
1300 if object__.is_some() {
1301 return Err(serde::de::Error::duplicate_field("sinkId"));
1302 }
1303 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1304 }
1305 GeneratedField::SchemaId => {
1306 if object__.is_some() {
1307 return Err(serde::de::Error::duplicate_field("schemaId"));
1308 }
1309 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1310 }
1311 GeneratedField::DatabaseId => {
1312 if object__.is_some() {
1313 return Err(serde::de::Error::duplicate_field("databaseId"));
1314 }
1315 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1316 }
1317 GeneratedField::SubscriptionId => {
1318 if object__.is_some() {
1319 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1320 }
1321 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1322 }
1323 GeneratedField::ConnectionId => {
1324 if object__.is_some() {
1325 return Err(serde::de::Error::duplicate_field("connectionId"));
1326 }
1327 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1328 }
1329 GeneratedField::SecretId => {
1330 if object__.is_some() {
1331 return Err(serde::de::Error::duplicate_field("secretId"));
1332 }
1333 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SecretId(x.0));
1334 }
1335 GeneratedField::FunctionId => {
1336 if object__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("functionId"));
1338 }
1339 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::FunctionId(x.0));
1340 }
1341 }
1342 }
1343 Ok(AlterOwnerRequest {
1344 owner_id: owner_id__.unwrap_or_default(),
1345 object: object__,
1346 })
1347 }
1348 }
1349 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1350 }
1351}
1352impl serde::Serialize for AlterOwnerResponse {
1353 #[allow(deprecated)]
1354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1355 where
1356 S: serde::Serializer,
1357 {
1358 use serde::ser::SerializeStruct;
1359 let mut len = 0;
1360 if self.status.is_some() {
1361 len += 1;
1362 }
1363 if self.version.is_some() {
1364 len += 1;
1365 }
1366 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1367 if let Some(v) = self.status.as_ref() {
1368 struct_ser.serialize_field("status", v)?;
1369 }
1370 if let Some(v) = self.version.as_ref() {
1371 struct_ser.serialize_field("version", v)?;
1372 }
1373 struct_ser.end()
1374 }
1375}
1376impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1377 #[allow(deprecated)]
1378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1379 where
1380 D: serde::Deserializer<'de>,
1381 {
1382 const FIELDS: &[&str] = &[
1383 "status",
1384 "version",
1385 ];
1386
1387 #[allow(clippy::enum_variant_names)]
1388 enum GeneratedField {
1389 Status,
1390 Version,
1391 }
1392 impl<'de> serde::Deserialize<'de> for GeneratedField {
1393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1394 where
1395 D: serde::Deserializer<'de>,
1396 {
1397 struct GeneratedVisitor;
1398
1399 impl serde::de::Visitor<'_> for GeneratedVisitor {
1400 type Value = GeneratedField;
1401
1402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1403 write!(formatter, "expected one of: {:?}", &FIELDS)
1404 }
1405
1406 #[allow(unused_variables)]
1407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1408 where
1409 E: serde::de::Error,
1410 {
1411 match value {
1412 "status" => Ok(GeneratedField::Status),
1413 "version" => Ok(GeneratedField::Version),
1414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1415 }
1416 }
1417 }
1418 deserializer.deserialize_identifier(GeneratedVisitor)
1419 }
1420 }
1421 struct GeneratedVisitor;
1422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1423 type Value = AlterOwnerResponse;
1424
1425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1426 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1427 }
1428
1429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1430 where
1431 V: serde::de::MapAccess<'de>,
1432 {
1433 let mut status__ = None;
1434 let mut version__ = None;
1435 while let Some(k) = map_.next_key()? {
1436 match k {
1437 GeneratedField::Status => {
1438 if status__.is_some() {
1439 return Err(serde::de::Error::duplicate_field("status"));
1440 }
1441 status__ = map_.next_value()?;
1442 }
1443 GeneratedField::Version => {
1444 if version__.is_some() {
1445 return Err(serde::de::Error::duplicate_field("version"));
1446 }
1447 version__ = map_.next_value()?;
1448 }
1449 }
1450 }
1451 Ok(AlterOwnerResponse {
1452 status: status__,
1453 version: version__,
1454 })
1455 }
1456 }
1457 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1458 }
1459}
1460impl serde::Serialize for AlterParallelismRequest {
1461 #[allow(deprecated)]
1462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1463 where
1464 S: serde::Serializer,
1465 {
1466 use serde::ser::SerializeStruct;
1467 let mut len = 0;
1468 if self.table_id != 0 {
1469 len += 1;
1470 }
1471 if self.parallelism.is_some() {
1472 len += 1;
1473 }
1474 if self.deferred {
1475 len += 1;
1476 }
1477 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1478 if self.table_id != 0 {
1479 struct_ser.serialize_field("tableId", &self.table_id)?;
1480 }
1481 if let Some(v) = self.parallelism.as_ref() {
1482 struct_ser.serialize_field("parallelism", v)?;
1483 }
1484 if self.deferred {
1485 struct_ser.serialize_field("deferred", &self.deferred)?;
1486 }
1487 struct_ser.end()
1488 }
1489}
1490impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1491 #[allow(deprecated)]
1492 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1493 where
1494 D: serde::Deserializer<'de>,
1495 {
1496 const FIELDS: &[&str] = &[
1497 "table_id",
1498 "tableId",
1499 "parallelism",
1500 "deferred",
1501 ];
1502
1503 #[allow(clippy::enum_variant_names)]
1504 enum GeneratedField {
1505 TableId,
1506 Parallelism,
1507 Deferred,
1508 }
1509 impl<'de> serde::Deserialize<'de> for GeneratedField {
1510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1511 where
1512 D: serde::Deserializer<'de>,
1513 {
1514 struct GeneratedVisitor;
1515
1516 impl serde::de::Visitor<'_> for GeneratedVisitor {
1517 type Value = GeneratedField;
1518
1519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1520 write!(formatter, "expected one of: {:?}", &FIELDS)
1521 }
1522
1523 #[allow(unused_variables)]
1524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1525 where
1526 E: serde::de::Error,
1527 {
1528 match value {
1529 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1530 "parallelism" => Ok(GeneratedField::Parallelism),
1531 "deferred" => Ok(GeneratedField::Deferred),
1532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1533 }
1534 }
1535 }
1536 deserializer.deserialize_identifier(GeneratedVisitor)
1537 }
1538 }
1539 struct GeneratedVisitor;
1540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1541 type Value = AlterParallelismRequest;
1542
1543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1544 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1545 }
1546
1547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1548 where
1549 V: serde::de::MapAccess<'de>,
1550 {
1551 let mut table_id__ = None;
1552 let mut parallelism__ = None;
1553 let mut deferred__ = None;
1554 while let Some(k) = map_.next_key()? {
1555 match k {
1556 GeneratedField::TableId => {
1557 if table_id__.is_some() {
1558 return Err(serde::de::Error::duplicate_field("tableId"));
1559 }
1560 table_id__ =
1561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1562 ;
1563 }
1564 GeneratedField::Parallelism => {
1565 if parallelism__.is_some() {
1566 return Err(serde::de::Error::duplicate_field("parallelism"));
1567 }
1568 parallelism__ = map_.next_value()?;
1569 }
1570 GeneratedField::Deferred => {
1571 if deferred__.is_some() {
1572 return Err(serde::de::Error::duplicate_field("deferred"));
1573 }
1574 deferred__ = Some(map_.next_value()?);
1575 }
1576 }
1577 }
1578 Ok(AlterParallelismRequest {
1579 table_id: table_id__.unwrap_or_default(),
1580 parallelism: parallelism__,
1581 deferred: deferred__.unwrap_or_default(),
1582 })
1583 }
1584 }
1585 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1586 }
1587}
1588impl serde::Serialize for AlterParallelismResponse {
1589 #[allow(deprecated)]
1590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1591 where
1592 S: serde::Serializer,
1593 {
1594 use serde::ser::SerializeStruct;
1595 let len = 0;
1596 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1597 struct_ser.end()
1598 }
1599}
1600impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1601 #[allow(deprecated)]
1602 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1603 where
1604 D: serde::Deserializer<'de>,
1605 {
1606 const FIELDS: &[&str] = &[
1607 ];
1608
1609 #[allow(clippy::enum_variant_names)]
1610 enum GeneratedField {
1611 }
1612 impl<'de> serde::Deserialize<'de> for GeneratedField {
1613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1614 where
1615 D: serde::Deserializer<'de>,
1616 {
1617 struct GeneratedVisitor;
1618
1619 impl serde::de::Visitor<'_> for GeneratedVisitor {
1620 type Value = GeneratedField;
1621
1622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1623 write!(formatter, "expected one of: {:?}", &FIELDS)
1624 }
1625
1626 #[allow(unused_variables)]
1627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1628 where
1629 E: serde::de::Error,
1630 {
1631 Err(serde::de::Error::unknown_field(value, FIELDS))
1632 }
1633 }
1634 deserializer.deserialize_identifier(GeneratedVisitor)
1635 }
1636 }
1637 struct GeneratedVisitor;
1638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1639 type Value = AlterParallelismResponse;
1640
1641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1642 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1643 }
1644
1645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1646 where
1647 V: serde::de::MapAccess<'de>,
1648 {
1649 while map_.next_key::<GeneratedField>()?.is_some() {
1650 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1651 }
1652 Ok(AlterParallelismResponse {
1653 })
1654 }
1655 }
1656 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1657 }
1658}
1659impl serde::Serialize for AlterResourceGroupRequest {
1660 #[allow(deprecated)]
1661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1662 where
1663 S: serde::Serializer,
1664 {
1665 use serde::ser::SerializeStruct;
1666 let mut len = 0;
1667 if self.table_id != 0 {
1668 len += 1;
1669 }
1670 if self.resource_group.is_some() {
1671 len += 1;
1672 }
1673 if self.deferred {
1674 len += 1;
1675 }
1676 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1677 if self.table_id != 0 {
1678 struct_ser.serialize_field("tableId", &self.table_id)?;
1679 }
1680 if let Some(v) = self.resource_group.as_ref() {
1681 struct_ser.serialize_field("resourceGroup", v)?;
1682 }
1683 if self.deferred {
1684 struct_ser.serialize_field("deferred", &self.deferred)?;
1685 }
1686 struct_ser.end()
1687 }
1688}
1689impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1690 #[allow(deprecated)]
1691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1692 where
1693 D: serde::Deserializer<'de>,
1694 {
1695 const FIELDS: &[&str] = &[
1696 "table_id",
1697 "tableId",
1698 "resource_group",
1699 "resourceGroup",
1700 "deferred",
1701 ];
1702
1703 #[allow(clippy::enum_variant_names)]
1704 enum GeneratedField {
1705 TableId,
1706 ResourceGroup,
1707 Deferred,
1708 }
1709 impl<'de> serde::Deserialize<'de> for GeneratedField {
1710 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1711 where
1712 D: serde::Deserializer<'de>,
1713 {
1714 struct GeneratedVisitor;
1715
1716 impl serde::de::Visitor<'_> for GeneratedVisitor {
1717 type Value = GeneratedField;
1718
1719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1720 write!(formatter, "expected one of: {:?}", &FIELDS)
1721 }
1722
1723 #[allow(unused_variables)]
1724 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1725 where
1726 E: serde::de::Error,
1727 {
1728 match value {
1729 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1730 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1731 "deferred" => Ok(GeneratedField::Deferred),
1732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1733 }
1734 }
1735 }
1736 deserializer.deserialize_identifier(GeneratedVisitor)
1737 }
1738 }
1739 struct GeneratedVisitor;
1740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1741 type Value = AlterResourceGroupRequest;
1742
1743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1744 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1745 }
1746
1747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1748 where
1749 V: serde::de::MapAccess<'de>,
1750 {
1751 let mut table_id__ = None;
1752 let mut resource_group__ = None;
1753 let mut deferred__ = None;
1754 while let Some(k) = map_.next_key()? {
1755 match k {
1756 GeneratedField::TableId => {
1757 if table_id__.is_some() {
1758 return Err(serde::de::Error::duplicate_field("tableId"));
1759 }
1760 table_id__ =
1761 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1762 ;
1763 }
1764 GeneratedField::ResourceGroup => {
1765 if resource_group__.is_some() {
1766 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1767 }
1768 resource_group__ = map_.next_value()?;
1769 }
1770 GeneratedField::Deferred => {
1771 if deferred__.is_some() {
1772 return Err(serde::de::Error::duplicate_field("deferred"));
1773 }
1774 deferred__ = Some(map_.next_value()?);
1775 }
1776 }
1777 }
1778 Ok(AlterResourceGroupRequest {
1779 table_id: table_id__.unwrap_or_default(),
1780 resource_group: resource_group__,
1781 deferred: deferred__.unwrap_or_default(),
1782 })
1783 }
1784 }
1785 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1786 }
1787}
1788impl serde::Serialize for AlterResourceGroupResponse {
1789 #[allow(deprecated)]
1790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1791 where
1792 S: serde::Serializer,
1793 {
1794 use serde::ser::SerializeStruct;
1795 let len = 0;
1796 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1797 struct_ser.end()
1798 }
1799}
1800impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1801 #[allow(deprecated)]
1802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1803 where
1804 D: serde::Deserializer<'de>,
1805 {
1806 const FIELDS: &[&str] = &[
1807 ];
1808
1809 #[allow(clippy::enum_variant_names)]
1810 enum GeneratedField {
1811 }
1812 impl<'de> serde::Deserialize<'de> for GeneratedField {
1813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1814 where
1815 D: serde::Deserializer<'de>,
1816 {
1817 struct GeneratedVisitor;
1818
1819 impl serde::de::Visitor<'_> for GeneratedVisitor {
1820 type Value = GeneratedField;
1821
1822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1823 write!(formatter, "expected one of: {:?}", &FIELDS)
1824 }
1825
1826 #[allow(unused_variables)]
1827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1828 where
1829 E: serde::de::Error,
1830 {
1831 Err(serde::de::Error::unknown_field(value, FIELDS))
1832 }
1833 }
1834 deserializer.deserialize_identifier(GeneratedVisitor)
1835 }
1836 }
1837 struct GeneratedVisitor;
1838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1839 type Value = AlterResourceGroupResponse;
1840
1841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1842 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1843 }
1844
1845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1846 where
1847 V: serde::de::MapAccess<'de>,
1848 {
1849 while map_.next_key::<GeneratedField>()?.is_some() {
1850 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1851 }
1852 Ok(AlterResourceGroupResponse {
1853 })
1854 }
1855 }
1856 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1857 }
1858}
1859impl serde::Serialize for AlterSecretRequest {
1860 #[allow(deprecated)]
1861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1862 where
1863 S: serde::Serializer,
1864 {
1865 use serde::ser::SerializeStruct;
1866 let mut len = 0;
1867 if self.secret_id != 0 {
1868 len += 1;
1869 }
1870 if !self.name.is_empty() {
1871 len += 1;
1872 }
1873 if !self.value.is_empty() {
1874 len += 1;
1875 }
1876 if self.database_id != 0 {
1877 len += 1;
1878 }
1879 if self.schema_id != 0 {
1880 len += 1;
1881 }
1882 if self.owner_id != 0 {
1883 len += 1;
1884 }
1885 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1886 if self.secret_id != 0 {
1887 struct_ser.serialize_field("secretId", &self.secret_id)?;
1888 }
1889 if !self.name.is_empty() {
1890 struct_ser.serialize_field("name", &self.name)?;
1891 }
1892 if !self.value.is_empty() {
1893 #[allow(clippy::needless_borrow)]
1894 #[allow(clippy::needless_borrows_for_generic_args)]
1895 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1896 }
1897 if self.database_id != 0 {
1898 struct_ser.serialize_field("databaseId", &self.database_id)?;
1899 }
1900 if self.schema_id != 0 {
1901 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1902 }
1903 if self.owner_id != 0 {
1904 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1905 }
1906 struct_ser.end()
1907 }
1908}
1909impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1910 #[allow(deprecated)]
1911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1912 where
1913 D: serde::Deserializer<'de>,
1914 {
1915 const FIELDS: &[&str] = &[
1916 "secret_id",
1917 "secretId",
1918 "name",
1919 "value",
1920 "database_id",
1921 "databaseId",
1922 "schema_id",
1923 "schemaId",
1924 "owner_id",
1925 "ownerId",
1926 ];
1927
1928 #[allow(clippy::enum_variant_names)]
1929 enum GeneratedField {
1930 SecretId,
1931 Name,
1932 Value,
1933 DatabaseId,
1934 SchemaId,
1935 OwnerId,
1936 }
1937 impl<'de> serde::Deserialize<'de> for GeneratedField {
1938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1939 where
1940 D: serde::Deserializer<'de>,
1941 {
1942 struct GeneratedVisitor;
1943
1944 impl serde::de::Visitor<'_> for GeneratedVisitor {
1945 type Value = GeneratedField;
1946
1947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1948 write!(formatter, "expected one of: {:?}", &FIELDS)
1949 }
1950
1951 #[allow(unused_variables)]
1952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1953 where
1954 E: serde::de::Error,
1955 {
1956 match value {
1957 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1958 "name" => Ok(GeneratedField::Name),
1959 "value" => Ok(GeneratedField::Value),
1960 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1961 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1962 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1964 }
1965 }
1966 }
1967 deserializer.deserialize_identifier(GeneratedVisitor)
1968 }
1969 }
1970 struct GeneratedVisitor;
1971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1972 type Value = AlterSecretRequest;
1973
1974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1975 formatter.write_str("struct ddl_service.AlterSecretRequest")
1976 }
1977
1978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
1979 where
1980 V: serde::de::MapAccess<'de>,
1981 {
1982 let mut secret_id__ = None;
1983 let mut name__ = None;
1984 let mut value__ = None;
1985 let mut database_id__ = None;
1986 let mut schema_id__ = None;
1987 let mut owner_id__ = None;
1988 while let Some(k) = map_.next_key()? {
1989 match k {
1990 GeneratedField::SecretId => {
1991 if secret_id__.is_some() {
1992 return Err(serde::de::Error::duplicate_field("secretId"));
1993 }
1994 secret_id__ =
1995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1996 ;
1997 }
1998 GeneratedField::Name => {
1999 if name__.is_some() {
2000 return Err(serde::de::Error::duplicate_field("name"));
2001 }
2002 name__ = Some(map_.next_value()?);
2003 }
2004 GeneratedField::Value => {
2005 if value__.is_some() {
2006 return Err(serde::de::Error::duplicate_field("value"));
2007 }
2008 value__ =
2009 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2010 ;
2011 }
2012 GeneratedField::DatabaseId => {
2013 if database_id__.is_some() {
2014 return Err(serde::de::Error::duplicate_field("databaseId"));
2015 }
2016 database_id__ =
2017 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2018 ;
2019 }
2020 GeneratedField::SchemaId => {
2021 if schema_id__.is_some() {
2022 return Err(serde::de::Error::duplicate_field("schemaId"));
2023 }
2024 schema_id__ =
2025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2026 ;
2027 }
2028 GeneratedField::OwnerId => {
2029 if owner_id__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("ownerId"));
2031 }
2032 owner_id__ =
2033 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2034 ;
2035 }
2036 }
2037 }
2038 Ok(AlterSecretRequest {
2039 secret_id: secret_id__.unwrap_or_default(),
2040 name: name__.unwrap_or_default(),
2041 value: value__.unwrap_or_default(),
2042 database_id: database_id__.unwrap_or_default(),
2043 schema_id: schema_id__.unwrap_or_default(),
2044 owner_id: owner_id__.unwrap_or_default(),
2045 })
2046 }
2047 }
2048 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
2049 }
2050}
2051impl serde::Serialize for AlterSecretResponse {
2052 #[allow(deprecated)]
2053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2054 where
2055 S: serde::Serializer,
2056 {
2057 use serde::ser::SerializeStruct;
2058 let mut len = 0;
2059 if self.version.is_some() {
2060 len += 1;
2061 }
2062 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
2063 if let Some(v) = self.version.as_ref() {
2064 struct_ser.serialize_field("version", v)?;
2065 }
2066 struct_ser.end()
2067 }
2068}
2069impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
2070 #[allow(deprecated)]
2071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2072 where
2073 D: serde::Deserializer<'de>,
2074 {
2075 const FIELDS: &[&str] = &[
2076 "version",
2077 ];
2078
2079 #[allow(clippy::enum_variant_names)]
2080 enum GeneratedField {
2081 Version,
2082 }
2083 impl<'de> serde::Deserialize<'de> for GeneratedField {
2084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2085 where
2086 D: serde::Deserializer<'de>,
2087 {
2088 struct GeneratedVisitor;
2089
2090 impl serde::de::Visitor<'_> for GeneratedVisitor {
2091 type Value = GeneratedField;
2092
2093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2094 write!(formatter, "expected one of: {:?}", &FIELDS)
2095 }
2096
2097 #[allow(unused_variables)]
2098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2099 where
2100 E: serde::de::Error,
2101 {
2102 match value {
2103 "version" => Ok(GeneratedField::Version),
2104 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2105 }
2106 }
2107 }
2108 deserializer.deserialize_identifier(GeneratedVisitor)
2109 }
2110 }
2111 struct GeneratedVisitor;
2112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2113 type Value = AlterSecretResponse;
2114
2115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2116 formatter.write_str("struct ddl_service.AlterSecretResponse")
2117 }
2118
2119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
2120 where
2121 V: serde::de::MapAccess<'de>,
2122 {
2123 let mut version__ = None;
2124 while let Some(k) = map_.next_key()? {
2125 match k {
2126 GeneratedField::Version => {
2127 if version__.is_some() {
2128 return Err(serde::de::Error::duplicate_field("version"));
2129 }
2130 version__ = map_.next_value()?;
2131 }
2132 }
2133 }
2134 Ok(AlterSecretResponse {
2135 version: version__,
2136 })
2137 }
2138 }
2139 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
2140 }
2141}
2142impl serde::Serialize for AlterSetSchemaRequest {
2143 #[allow(deprecated)]
2144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2145 where
2146 S: serde::Serializer,
2147 {
2148 use serde::ser::SerializeStruct;
2149 let mut len = 0;
2150 if self.new_schema_id != 0 {
2151 len += 1;
2152 }
2153 if self.object.is_some() {
2154 len += 1;
2155 }
2156 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
2157 if self.new_schema_id != 0 {
2158 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
2159 }
2160 if let Some(v) = self.object.as_ref() {
2161 match v {
2162 alter_set_schema_request::Object::TableId(v) => {
2163 struct_ser.serialize_field("tableId", v)?;
2164 }
2165 alter_set_schema_request::Object::ViewId(v) => {
2166 struct_ser.serialize_field("viewId", v)?;
2167 }
2168 alter_set_schema_request::Object::SourceId(v) => {
2169 struct_ser.serialize_field("sourceId", v)?;
2170 }
2171 alter_set_schema_request::Object::SinkId(v) => {
2172 struct_ser.serialize_field("sinkId", v)?;
2173 }
2174 alter_set_schema_request::Object::FunctionId(v) => {
2175 struct_ser.serialize_field("functionId", v)?;
2176 }
2177 alter_set_schema_request::Object::ConnectionId(v) => {
2178 struct_ser.serialize_field("connectionId", v)?;
2179 }
2180 alter_set_schema_request::Object::SubscriptionId(v) => {
2181 struct_ser.serialize_field("subscriptionId", v)?;
2182 }
2183 }
2184 }
2185 struct_ser.end()
2186 }
2187}
2188impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
2189 #[allow(deprecated)]
2190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2191 where
2192 D: serde::Deserializer<'de>,
2193 {
2194 const FIELDS: &[&str] = &[
2195 "new_schema_id",
2196 "newSchemaId",
2197 "table_id",
2198 "tableId",
2199 "view_id",
2200 "viewId",
2201 "source_id",
2202 "sourceId",
2203 "sink_id",
2204 "sinkId",
2205 "function_id",
2206 "functionId",
2207 "connection_id",
2208 "connectionId",
2209 "subscription_id",
2210 "subscriptionId",
2211 ];
2212
2213 #[allow(clippy::enum_variant_names)]
2214 enum GeneratedField {
2215 NewSchemaId,
2216 TableId,
2217 ViewId,
2218 SourceId,
2219 SinkId,
2220 FunctionId,
2221 ConnectionId,
2222 SubscriptionId,
2223 }
2224 impl<'de> serde::Deserialize<'de> for GeneratedField {
2225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2226 where
2227 D: serde::Deserializer<'de>,
2228 {
2229 struct GeneratedVisitor;
2230
2231 impl serde::de::Visitor<'_> for GeneratedVisitor {
2232 type Value = GeneratedField;
2233
2234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2235 write!(formatter, "expected one of: {:?}", &FIELDS)
2236 }
2237
2238 #[allow(unused_variables)]
2239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2240 where
2241 E: serde::de::Error,
2242 {
2243 match value {
2244 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2245 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2246 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2247 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2248 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2249 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2250 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2251 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2252 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2253 }
2254 }
2255 }
2256 deserializer.deserialize_identifier(GeneratedVisitor)
2257 }
2258 }
2259 struct GeneratedVisitor;
2260 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2261 type Value = AlterSetSchemaRequest;
2262
2263 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2264 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2265 }
2266
2267 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2268 where
2269 V: serde::de::MapAccess<'de>,
2270 {
2271 let mut new_schema_id__ = None;
2272 let mut object__ = None;
2273 while let Some(k) = map_.next_key()? {
2274 match k {
2275 GeneratedField::NewSchemaId => {
2276 if new_schema_id__.is_some() {
2277 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2278 }
2279 new_schema_id__ =
2280 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2281 ;
2282 }
2283 GeneratedField::TableId => {
2284 if object__.is_some() {
2285 return Err(serde::de::Error::duplicate_field("tableId"));
2286 }
2287 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2288 }
2289 GeneratedField::ViewId => {
2290 if object__.is_some() {
2291 return Err(serde::de::Error::duplicate_field("viewId"));
2292 }
2293 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2294 }
2295 GeneratedField::SourceId => {
2296 if object__.is_some() {
2297 return Err(serde::de::Error::duplicate_field("sourceId"));
2298 }
2299 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2300 }
2301 GeneratedField::SinkId => {
2302 if object__.is_some() {
2303 return Err(serde::de::Error::duplicate_field("sinkId"));
2304 }
2305 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2306 }
2307 GeneratedField::FunctionId => {
2308 if object__.is_some() {
2309 return Err(serde::de::Error::duplicate_field("functionId"));
2310 }
2311 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2312 }
2313 GeneratedField::ConnectionId => {
2314 if object__.is_some() {
2315 return Err(serde::de::Error::duplicate_field("connectionId"));
2316 }
2317 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2318 }
2319 GeneratedField::SubscriptionId => {
2320 if object__.is_some() {
2321 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2322 }
2323 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2324 }
2325 }
2326 }
2327 Ok(AlterSetSchemaRequest {
2328 new_schema_id: new_schema_id__.unwrap_or_default(),
2329 object: object__,
2330 })
2331 }
2332 }
2333 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2334 }
2335}
2336impl serde::Serialize for AlterSetSchemaResponse {
2337 #[allow(deprecated)]
2338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2339 where
2340 S: serde::Serializer,
2341 {
2342 use serde::ser::SerializeStruct;
2343 let mut len = 0;
2344 if self.status.is_some() {
2345 len += 1;
2346 }
2347 if self.version.is_some() {
2348 len += 1;
2349 }
2350 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2351 if let Some(v) = self.status.as_ref() {
2352 struct_ser.serialize_field("status", v)?;
2353 }
2354 if let Some(v) = self.version.as_ref() {
2355 struct_ser.serialize_field("version", v)?;
2356 }
2357 struct_ser.end()
2358 }
2359}
2360impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2361 #[allow(deprecated)]
2362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2363 where
2364 D: serde::Deserializer<'de>,
2365 {
2366 const FIELDS: &[&str] = &[
2367 "status",
2368 "version",
2369 ];
2370
2371 #[allow(clippy::enum_variant_names)]
2372 enum GeneratedField {
2373 Status,
2374 Version,
2375 }
2376 impl<'de> serde::Deserialize<'de> for GeneratedField {
2377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2378 where
2379 D: serde::Deserializer<'de>,
2380 {
2381 struct GeneratedVisitor;
2382
2383 impl serde::de::Visitor<'_> for GeneratedVisitor {
2384 type Value = GeneratedField;
2385
2386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2387 write!(formatter, "expected one of: {:?}", &FIELDS)
2388 }
2389
2390 #[allow(unused_variables)]
2391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2392 where
2393 E: serde::de::Error,
2394 {
2395 match value {
2396 "status" => Ok(GeneratedField::Status),
2397 "version" => Ok(GeneratedField::Version),
2398 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2399 }
2400 }
2401 }
2402 deserializer.deserialize_identifier(GeneratedVisitor)
2403 }
2404 }
2405 struct GeneratedVisitor;
2406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2407 type Value = AlterSetSchemaResponse;
2408
2409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2410 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2411 }
2412
2413 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2414 where
2415 V: serde::de::MapAccess<'de>,
2416 {
2417 let mut status__ = None;
2418 let mut version__ = None;
2419 while let Some(k) = map_.next_key()? {
2420 match k {
2421 GeneratedField::Status => {
2422 if status__.is_some() {
2423 return Err(serde::de::Error::duplicate_field("status"));
2424 }
2425 status__ = map_.next_value()?;
2426 }
2427 GeneratedField::Version => {
2428 if version__.is_some() {
2429 return Err(serde::de::Error::duplicate_field("version"));
2430 }
2431 version__ = map_.next_value()?;
2432 }
2433 }
2434 }
2435 Ok(AlterSetSchemaResponse {
2436 status: status__,
2437 version: version__,
2438 })
2439 }
2440 }
2441 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2442 }
2443}
2444impl serde::Serialize for AlterSourceRequest {
2445 #[allow(deprecated)]
2446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2447 where
2448 S: serde::Serializer,
2449 {
2450 use serde::ser::SerializeStruct;
2451 let mut len = 0;
2452 if self.source.is_some() {
2453 len += 1;
2454 }
2455 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2456 if let Some(v) = self.source.as_ref() {
2457 struct_ser.serialize_field("source", v)?;
2458 }
2459 struct_ser.end()
2460 }
2461}
2462impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2463 #[allow(deprecated)]
2464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2465 where
2466 D: serde::Deserializer<'de>,
2467 {
2468 const FIELDS: &[&str] = &[
2469 "source",
2470 ];
2471
2472 #[allow(clippy::enum_variant_names)]
2473 enum GeneratedField {
2474 Source,
2475 }
2476 impl<'de> serde::Deserialize<'de> for GeneratedField {
2477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2478 where
2479 D: serde::Deserializer<'de>,
2480 {
2481 struct GeneratedVisitor;
2482
2483 impl serde::de::Visitor<'_> for GeneratedVisitor {
2484 type Value = GeneratedField;
2485
2486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2487 write!(formatter, "expected one of: {:?}", &FIELDS)
2488 }
2489
2490 #[allow(unused_variables)]
2491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2492 where
2493 E: serde::de::Error,
2494 {
2495 match value {
2496 "source" => Ok(GeneratedField::Source),
2497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2498 }
2499 }
2500 }
2501 deserializer.deserialize_identifier(GeneratedVisitor)
2502 }
2503 }
2504 struct GeneratedVisitor;
2505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2506 type Value = AlterSourceRequest;
2507
2508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2509 formatter.write_str("struct ddl_service.AlterSourceRequest")
2510 }
2511
2512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2513 where
2514 V: serde::de::MapAccess<'de>,
2515 {
2516 let mut source__ = None;
2517 while let Some(k) = map_.next_key()? {
2518 match k {
2519 GeneratedField::Source => {
2520 if source__.is_some() {
2521 return Err(serde::de::Error::duplicate_field("source"));
2522 }
2523 source__ = map_.next_value()?;
2524 }
2525 }
2526 }
2527 Ok(AlterSourceRequest {
2528 source: source__,
2529 })
2530 }
2531 }
2532 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2533 }
2534}
2535impl serde::Serialize for AlterSourceResponse {
2536 #[allow(deprecated)]
2537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2538 where
2539 S: serde::Serializer,
2540 {
2541 use serde::ser::SerializeStruct;
2542 let mut len = 0;
2543 if self.status.is_some() {
2544 len += 1;
2545 }
2546 if self.version.is_some() {
2547 len += 1;
2548 }
2549 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2550 if let Some(v) = self.status.as_ref() {
2551 struct_ser.serialize_field("status", v)?;
2552 }
2553 if let Some(v) = self.version.as_ref() {
2554 struct_ser.serialize_field("version", v)?;
2555 }
2556 struct_ser.end()
2557 }
2558}
2559impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2560 #[allow(deprecated)]
2561 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2562 where
2563 D: serde::Deserializer<'de>,
2564 {
2565 const FIELDS: &[&str] = &[
2566 "status",
2567 "version",
2568 ];
2569
2570 #[allow(clippy::enum_variant_names)]
2571 enum GeneratedField {
2572 Status,
2573 Version,
2574 }
2575 impl<'de> serde::Deserialize<'de> for GeneratedField {
2576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2577 where
2578 D: serde::Deserializer<'de>,
2579 {
2580 struct GeneratedVisitor;
2581
2582 impl serde::de::Visitor<'_> for GeneratedVisitor {
2583 type Value = GeneratedField;
2584
2585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2586 write!(formatter, "expected one of: {:?}", &FIELDS)
2587 }
2588
2589 #[allow(unused_variables)]
2590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2591 where
2592 E: serde::de::Error,
2593 {
2594 match value {
2595 "status" => Ok(GeneratedField::Status),
2596 "version" => Ok(GeneratedField::Version),
2597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2598 }
2599 }
2600 }
2601 deserializer.deserialize_identifier(GeneratedVisitor)
2602 }
2603 }
2604 struct GeneratedVisitor;
2605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2606 type Value = AlterSourceResponse;
2607
2608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2609 formatter.write_str("struct ddl_service.AlterSourceResponse")
2610 }
2611
2612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2613 where
2614 V: serde::de::MapAccess<'de>,
2615 {
2616 let mut status__ = None;
2617 let mut version__ = None;
2618 while let Some(k) = map_.next_key()? {
2619 match k {
2620 GeneratedField::Status => {
2621 if status__.is_some() {
2622 return Err(serde::de::Error::duplicate_field("status"));
2623 }
2624 status__ = map_.next_value()?;
2625 }
2626 GeneratedField::Version => {
2627 if version__.is_some() {
2628 return Err(serde::de::Error::duplicate_field("version"));
2629 }
2630 version__ = map_.next_value()?;
2631 }
2632 }
2633 }
2634 Ok(AlterSourceResponse {
2635 status: status__,
2636 version: version__,
2637 })
2638 }
2639 }
2640 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2641 }
2642}
2643impl serde::Serialize for AlterStreamingJobConfigRequest {
2644 #[allow(deprecated)]
2645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2646 where
2647 S: serde::Serializer,
2648 {
2649 use serde::ser::SerializeStruct;
2650 let mut len = 0;
2651 if self.job_id != 0 {
2652 len += 1;
2653 }
2654 if !self.entries_to_add.is_empty() {
2655 len += 1;
2656 }
2657 if !self.keys_to_remove.is_empty() {
2658 len += 1;
2659 }
2660 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigRequest", len)?;
2661 if self.job_id != 0 {
2662 struct_ser.serialize_field("jobId", &self.job_id)?;
2663 }
2664 if !self.entries_to_add.is_empty() {
2665 struct_ser.serialize_field("entriesToAdd", &self.entries_to_add)?;
2666 }
2667 if !self.keys_to_remove.is_empty() {
2668 struct_ser.serialize_field("keysToRemove", &self.keys_to_remove)?;
2669 }
2670 struct_ser.end()
2671 }
2672}
2673impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigRequest {
2674 #[allow(deprecated)]
2675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2676 where
2677 D: serde::Deserializer<'de>,
2678 {
2679 const FIELDS: &[&str] = &[
2680 "job_id",
2681 "jobId",
2682 "entries_to_add",
2683 "entriesToAdd",
2684 "keys_to_remove",
2685 "keysToRemove",
2686 ];
2687
2688 #[allow(clippy::enum_variant_names)]
2689 enum GeneratedField {
2690 JobId,
2691 EntriesToAdd,
2692 KeysToRemove,
2693 }
2694 impl<'de> serde::Deserialize<'de> for GeneratedField {
2695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2696 where
2697 D: serde::Deserializer<'de>,
2698 {
2699 struct GeneratedVisitor;
2700
2701 impl serde::de::Visitor<'_> for GeneratedVisitor {
2702 type Value = GeneratedField;
2703
2704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2705 write!(formatter, "expected one of: {:?}", &FIELDS)
2706 }
2707
2708 #[allow(unused_variables)]
2709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2710 where
2711 E: serde::de::Error,
2712 {
2713 match value {
2714 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2715 "entriesToAdd" | "entries_to_add" => Ok(GeneratedField::EntriesToAdd),
2716 "keysToRemove" | "keys_to_remove" => Ok(GeneratedField::KeysToRemove),
2717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2718 }
2719 }
2720 }
2721 deserializer.deserialize_identifier(GeneratedVisitor)
2722 }
2723 }
2724 struct GeneratedVisitor;
2725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2726 type Value = AlterStreamingJobConfigRequest;
2727
2728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2729 formatter.write_str("struct ddl_service.AlterStreamingJobConfigRequest")
2730 }
2731
2732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigRequest, V::Error>
2733 where
2734 V: serde::de::MapAccess<'de>,
2735 {
2736 let mut job_id__ = None;
2737 let mut entries_to_add__ = None;
2738 let mut keys_to_remove__ = None;
2739 while let Some(k) = map_.next_key()? {
2740 match k {
2741 GeneratedField::JobId => {
2742 if job_id__.is_some() {
2743 return Err(serde::de::Error::duplicate_field("jobId"));
2744 }
2745 job_id__ =
2746 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2747 ;
2748 }
2749 GeneratedField::EntriesToAdd => {
2750 if entries_to_add__.is_some() {
2751 return Err(serde::de::Error::duplicate_field("entriesToAdd"));
2752 }
2753 entries_to_add__ = Some(
2754 map_.next_value::<std::collections::HashMap<_, _>>()?
2755 );
2756 }
2757 GeneratedField::KeysToRemove => {
2758 if keys_to_remove__.is_some() {
2759 return Err(serde::de::Error::duplicate_field("keysToRemove"));
2760 }
2761 keys_to_remove__ = Some(map_.next_value()?);
2762 }
2763 }
2764 }
2765 Ok(AlterStreamingJobConfigRequest {
2766 job_id: job_id__.unwrap_or_default(),
2767 entries_to_add: entries_to_add__.unwrap_or_default(),
2768 keys_to_remove: keys_to_remove__.unwrap_or_default(),
2769 })
2770 }
2771 }
2772 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigRequest", FIELDS, GeneratedVisitor)
2773 }
2774}
2775impl serde::Serialize for AlterStreamingJobConfigResponse {
2776 #[allow(deprecated)]
2777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2778 where
2779 S: serde::Serializer,
2780 {
2781 use serde::ser::SerializeStruct;
2782 let len = 0;
2783 let struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigResponse", len)?;
2784 struct_ser.end()
2785 }
2786}
2787impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigResponse {
2788 #[allow(deprecated)]
2789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2790 where
2791 D: serde::Deserializer<'de>,
2792 {
2793 const FIELDS: &[&str] = &[
2794 ];
2795
2796 #[allow(clippy::enum_variant_names)]
2797 enum GeneratedField {
2798 }
2799 impl<'de> serde::Deserialize<'de> for GeneratedField {
2800 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2801 where
2802 D: serde::Deserializer<'de>,
2803 {
2804 struct GeneratedVisitor;
2805
2806 impl serde::de::Visitor<'_> for GeneratedVisitor {
2807 type Value = GeneratedField;
2808
2809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2810 write!(formatter, "expected one of: {:?}", &FIELDS)
2811 }
2812
2813 #[allow(unused_variables)]
2814 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2815 where
2816 E: serde::de::Error,
2817 {
2818 Err(serde::de::Error::unknown_field(value, FIELDS))
2819 }
2820 }
2821 deserializer.deserialize_identifier(GeneratedVisitor)
2822 }
2823 }
2824 struct GeneratedVisitor;
2825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2826 type Value = AlterStreamingJobConfigResponse;
2827
2828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2829 formatter.write_str("struct ddl_service.AlterStreamingJobConfigResponse")
2830 }
2831
2832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigResponse, V::Error>
2833 where
2834 V: serde::de::MapAccess<'de>,
2835 {
2836 while map_.next_key::<GeneratedField>()?.is_some() {
2837 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2838 }
2839 Ok(AlterStreamingJobConfigResponse {
2840 })
2841 }
2842 }
2843 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigResponse", FIELDS, GeneratedVisitor)
2844 }
2845}
2846impl serde::Serialize for AlterSubscriptionRetentionRequest {
2847 #[allow(deprecated)]
2848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2849 where
2850 S: serde::Serializer,
2851 {
2852 use serde::ser::SerializeStruct;
2853 let mut len = 0;
2854 if self.subscription_id != 0 {
2855 len += 1;
2856 }
2857 if self.retention_seconds != 0 {
2858 len += 1;
2859 }
2860 if !self.definition.is_empty() {
2861 len += 1;
2862 }
2863 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionRequest", len)?;
2864 if self.subscription_id != 0 {
2865 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
2866 }
2867 if self.retention_seconds != 0 {
2868 #[allow(clippy::needless_borrow)]
2869 #[allow(clippy::needless_borrows_for_generic_args)]
2870 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
2871 }
2872 if !self.definition.is_empty() {
2873 struct_ser.serialize_field("definition", &self.definition)?;
2874 }
2875 struct_ser.end()
2876 }
2877}
2878impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionRequest {
2879 #[allow(deprecated)]
2880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2881 where
2882 D: serde::Deserializer<'de>,
2883 {
2884 const FIELDS: &[&str] = &[
2885 "subscription_id",
2886 "subscriptionId",
2887 "retention_seconds",
2888 "retentionSeconds",
2889 "definition",
2890 ];
2891
2892 #[allow(clippy::enum_variant_names)]
2893 enum GeneratedField {
2894 SubscriptionId,
2895 RetentionSeconds,
2896 Definition,
2897 }
2898 impl<'de> serde::Deserialize<'de> for GeneratedField {
2899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2900 where
2901 D: serde::Deserializer<'de>,
2902 {
2903 struct GeneratedVisitor;
2904
2905 impl serde::de::Visitor<'_> for GeneratedVisitor {
2906 type Value = GeneratedField;
2907
2908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2909 write!(formatter, "expected one of: {:?}", &FIELDS)
2910 }
2911
2912 #[allow(unused_variables)]
2913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2914 where
2915 E: serde::de::Error,
2916 {
2917 match value {
2918 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2919 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
2920 "definition" => Ok(GeneratedField::Definition),
2921 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2922 }
2923 }
2924 }
2925 deserializer.deserialize_identifier(GeneratedVisitor)
2926 }
2927 }
2928 struct GeneratedVisitor;
2929 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2930 type Value = AlterSubscriptionRetentionRequest;
2931
2932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2933 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionRequest")
2934 }
2935
2936 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionRequest, V::Error>
2937 where
2938 V: serde::de::MapAccess<'de>,
2939 {
2940 let mut subscription_id__ = None;
2941 let mut retention_seconds__ = None;
2942 let mut definition__ = None;
2943 while let Some(k) = map_.next_key()? {
2944 match k {
2945 GeneratedField::SubscriptionId => {
2946 if subscription_id__.is_some() {
2947 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2948 }
2949 subscription_id__ =
2950 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2951 ;
2952 }
2953 GeneratedField::RetentionSeconds => {
2954 if retention_seconds__.is_some() {
2955 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
2956 }
2957 retention_seconds__ =
2958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2959 ;
2960 }
2961 GeneratedField::Definition => {
2962 if definition__.is_some() {
2963 return Err(serde::de::Error::duplicate_field("definition"));
2964 }
2965 definition__ = Some(map_.next_value()?);
2966 }
2967 }
2968 }
2969 Ok(AlterSubscriptionRetentionRequest {
2970 subscription_id: subscription_id__.unwrap_or_default(),
2971 retention_seconds: retention_seconds__.unwrap_or_default(),
2972 definition: definition__.unwrap_or_default(),
2973 })
2974 }
2975 }
2976 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionRequest", FIELDS, GeneratedVisitor)
2977 }
2978}
2979impl serde::Serialize for AlterSubscriptionRetentionResponse {
2980 #[allow(deprecated)]
2981 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2982 where
2983 S: serde::Serializer,
2984 {
2985 use serde::ser::SerializeStruct;
2986 let mut len = 0;
2987 if self.status.is_some() {
2988 len += 1;
2989 }
2990 if self.version.is_some() {
2991 len += 1;
2992 }
2993 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionResponse", len)?;
2994 if let Some(v) = self.status.as_ref() {
2995 struct_ser.serialize_field("status", v)?;
2996 }
2997 if let Some(v) = self.version.as_ref() {
2998 struct_ser.serialize_field("version", v)?;
2999 }
3000 struct_ser.end()
3001 }
3002}
3003impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionResponse {
3004 #[allow(deprecated)]
3005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3006 where
3007 D: serde::Deserializer<'de>,
3008 {
3009 const FIELDS: &[&str] = &[
3010 "status",
3011 "version",
3012 ];
3013
3014 #[allow(clippy::enum_variant_names)]
3015 enum GeneratedField {
3016 Status,
3017 Version,
3018 }
3019 impl<'de> serde::Deserialize<'de> for GeneratedField {
3020 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3021 where
3022 D: serde::Deserializer<'de>,
3023 {
3024 struct GeneratedVisitor;
3025
3026 impl serde::de::Visitor<'_> for GeneratedVisitor {
3027 type Value = GeneratedField;
3028
3029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3030 write!(formatter, "expected one of: {:?}", &FIELDS)
3031 }
3032
3033 #[allow(unused_variables)]
3034 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3035 where
3036 E: serde::de::Error,
3037 {
3038 match value {
3039 "status" => Ok(GeneratedField::Status),
3040 "version" => Ok(GeneratedField::Version),
3041 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3042 }
3043 }
3044 }
3045 deserializer.deserialize_identifier(GeneratedVisitor)
3046 }
3047 }
3048 struct GeneratedVisitor;
3049 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3050 type Value = AlterSubscriptionRetentionResponse;
3051
3052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3053 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionResponse")
3054 }
3055
3056 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionResponse, V::Error>
3057 where
3058 V: serde::de::MapAccess<'de>,
3059 {
3060 let mut status__ = None;
3061 let mut version__ = None;
3062 while let Some(k) = map_.next_key()? {
3063 match k {
3064 GeneratedField::Status => {
3065 if status__.is_some() {
3066 return Err(serde::de::Error::duplicate_field("status"));
3067 }
3068 status__ = map_.next_value()?;
3069 }
3070 GeneratedField::Version => {
3071 if version__.is_some() {
3072 return Err(serde::de::Error::duplicate_field("version"));
3073 }
3074 version__ = map_.next_value()?;
3075 }
3076 }
3077 }
3078 Ok(AlterSubscriptionRetentionResponse {
3079 status: status__,
3080 version: version__,
3081 })
3082 }
3083 }
3084 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionResponse", FIELDS, GeneratedVisitor)
3085 }
3086}
3087impl serde::Serialize for AlterSwapRenameRequest {
3088 #[allow(deprecated)]
3089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3090 where
3091 S: serde::Serializer,
3092 {
3093 use serde::ser::SerializeStruct;
3094 let mut len = 0;
3095 if self.object.is_some() {
3096 len += 1;
3097 }
3098 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
3099 if let Some(v) = self.object.as_ref() {
3100 match v {
3101 alter_swap_rename_request::Object::Schema(v) => {
3102 struct_ser.serialize_field("schema", v)?;
3103 }
3104 alter_swap_rename_request::Object::Table(v) => {
3105 struct_ser.serialize_field("table", v)?;
3106 }
3107 alter_swap_rename_request::Object::View(v) => {
3108 struct_ser.serialize_field("view", v)?;
3109 }
3110 alter_swap_rename_request::Object::Source(v) => {
3111 struct_ser.serialize_field("source", v)?;
3112 }
3113 alter_swap_rename_request::Object::Sink(v) => {
3114 struct_ser.serialize_field("sink", v)?;
3115 }
3116 alter_swap_rename_request::Object::Subscription(v) => {
3117 struct_ser.serialize_field("subscription", v)?;
3118 }
3119 }
3120 }
3121 struct_ser.end()
3122 }
3123}
3124impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
3125 #[allow(deprecated)]
3126 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3127 where
3128 D: serde::Deserializer<'de>,
3129 {
3130 const FIELDS: &[&str] = &[
3131 "schema",
3132 "table",
3133 "view",
3134 "source",
3135 "sink",
3136 "subscription",
3137 ];
3138
3139 #[allow(clippy::enum_variant_names)]
3140 enum GeneratedField {
3141 Schema,
3142 Table,
3143 View,
3144 Source,
3145 Sink,
3146 Subscription,
3147 }
3148 impl<'de> serde::Deserialize<'de> for GeneratedField {
3149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3150 where
3151 D: serde::Deserializer<'de>,
3152 {
3153 struct GeneratedVisitor;
3154
3155 impl serde::de::Visitor<'_> for GeneratedVisitor {
3156 type Value = GeneratedField;
3157
3158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3159 write!(formatter, "expected one of: {:?}", &FIELDS)
3160 }
3161
3162 #[allow(unused_variables)]
3163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3164 where
3165 E: serde::de::Error,
3166 {
3167 match value {
3168 "schema" => Ok(GeneratedField::Schema),
3169 "table" => Ok(GeneratedField::Table),
3170 "view" => Ok(GeneratedField::View),
3171 "source" => Ok(GeneratedField::Source),
3172 "sink" => Ok(GeneratedField::Sink),
3173 "subscription" => Ok(GeneratedField::Subscription),
3174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3175 }
3176 }
3177 }
3178 deserializer.deserialize_identifier(GeneratedVisitor)
3179 }
3180 }
3181 struct GeneratedVisitor;
3182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3183 type Value = AlterSwapRenameRequest;
3184
3185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3186 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
3187 }
3188
3189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
3190 where
3191 V: serde::de::MapAccess<'de>,
3192 {
3193 let mut object__ = None;
3194 while let Some(k) = map_.next_key()? {
3195 match k {
3196 GeneratedField::Schema => {
3197 if object__.is_some() {
3198 return Err(serde::de::Error::duplicate_field("schema"));
3199 }
3200 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
3201;
3202 }
3203 GeneratedField::Table => {
3204 if object__.is_some() {
3205 return Err(serde::de::Error::duplicate_field("table"));
3206 }
3207 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
3208;
3209 }
3210 GeneratedField::View => {
3211 if object__.is_some() {
3212 return Err(serde::de::Error::duplicate_field("view"));
3213 }
3214 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
3215;
3216 }
3217 GeneratedField::Source => {
3218 if object__.is_some() {
3219 return Err(serde::de::Error::duplicate_field("source"));
3220 }
3221 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
3222;
3223 }
3224 GeneratedField::Sink => {
3225 if object__.is_some() {
3226 return Err(serde::de::Error::duplicate_field("sink"));
3227 }
3228 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
3229;
3230 }
3231 GeneratedField::Subscription => {
3232 if object__.is_some() {
3233 return Err(serde::de::Error::duplicate_field("subscription"));
3234 }
3235 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
3236;
3237 }
3238 }
3239 }
3240 Ok(AlterSwapRenameRequest {
3241 object: object__,
3242 })
3243 }
3244 }
3245 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
3246 }
3247}
3248impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
3249 #[allow(deprecated)]
3250 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3251 where
3252 S: serde::Serializer,
3253 {
3254 use serde::ser::SerializeStruct;
3255 let mut len = 0;
3256 if self.src_object_id != 0 {
3257 len += 1;
3258 }
3259 if self.dst_object_id != 0 {
3260 len += 1;
3261 }
3262 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
3263 if self.src_object_id != 0 {
3264 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
3265 }
3266 if self.dst_object_id != 0 {
3267 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
3268 }
3269 struct_ser.end()
3270 }
3271}
3272impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
3273 #[allow(deprecated)]
3274 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3275 where
3276 D: serde::Deserializer<'de>,
3277 {
3278 const FIELDS: &[&str] = &[
3279 "src_object_id",
3280 "srcObjectId",
3281 "dst_object_id",
3282 "dstObjectId",
3283 ];
3284
3285 #[allow(clippy::enum_variant_names)]
3286 enum GeneratedField {
3287 SrcObjectId,
3288 DstObjectId,
3289 }
3290 impl<'de> serde::Deserialize<'de> for GeneratedField {
3291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3292 where
3293 D: serde::Deserializer<'de>,
3294 {
3295 struct GeneratedVisitor;
3296
3297 impl serde::de::Visitor<'_> for GeneratedVisitor {
3298 type Value = GeneratedField;
3299
3300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3301 write!(formatter, "expected one of: {:?}", &FIELDS)
3302 }
3303
3304 #[allow(unused_variables)]
3305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3306 where
3307 E: serde::de::Error,
3308 {
3309 match value {
3310 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
3311 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
3312 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3313 }
3314 }
3315 }
3316 deserializer.deserialize_identifier(GeneratedVisitor)
3317 }
3318 }
3319 struct GeneratedVisitor;
3320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3321 type Value = alter_swap_rename_request::ObjectNameSwapPair;
3322
3323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3324 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
3325 }
3326
3327 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
3328 where
3329 V: serde::de::MapAccess<'de>,
3330 {
3331 let mut src_object_id__ = None;
3332 let mut dst_object_id__ = None;
3333 while let Some(k) = map_.next_key()? {
3334 match k {
3335 GeneratedField::SrcObjectId => {
3336 if src_object_id__.is_some() {
3337 return Err(serde::de::Error::duplicate_field("srcObjectId"));
3338 }
3339 src_object_id__ =
3340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3341 ;
3342 }
3343 GeneratedField::DstObjectId => {
3344 if dst_object_id__.is_some() {
3345 return Err(serde::de::Error::duplicate_field("dstObjectId"));
3346 }
3347 dst_object_id__ =
3348 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3349 ;
3350 }
3351 }
3352 }
3353 Ok(alter_swap_rename_request::ObjectNameSwapPair {
3354 src_object_id: src_object_id__.unwrap_or_default(),
3355 dst_object_id: dst_object_id__.unwrap_or_default(),
3356 })
3357 }
3358 }
3359 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
3360 }
3361}
3362impl serde::Serialize for AlterSwapRenameResponse {
3363 #[allow(deprecated)]
3364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3365 where
3366 S: serde::Serializer,
3367 {
3368 use serde::ser::SerializeStruct;
3369 let mut len = 0;
3370 if self.status.is_some() {
3371 len += 1;
3372 }
3373 if self.version.is_some() {
3374 len += 1;
3375 }
3376 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
3377 if let Some(v) = self.status.as_ref() {
3378 struct_ser.serialize_field("status", v)?;
3379 }
3380 if let Some(v) = self.version.as_ref() {
3381 struct_ser.serialize_field("version", v)?;
3382 }
3383 struct_ser.end()
3384 }
3385}
3386impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
3387 #[allow(deprecated)]
3388 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3389 where
3390 D: serde::Deserializer<'de>,
3391 {
3392 const FIELDS: &[&str] = &[
3393 "status",
3394 "version",
3395 ];
3396
3397 #[allow(clippy::enum_variant_names)]
3398 enum GeneratedField {
3399 Status,
3400 Version,
3401 }
3402 impl<'de> serde::Deserialize<'de> for GeneratedField {
3403 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3404 where
3405 D: serde::Deserializer<'de>,
3406 {
3407 struct GeneratedVisitor;
3408
3409 impl serde::de::Visitor<'_> for GeneratedVisitor {
3410 type Value = GeneratedField;
3411
3412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3413 write!(formatter, "expected one of: {:?}", &FIELDS)
3414 }
3415
3416 #[allow(unused_variables)]
3417 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3418 where
3419 E: serde::de::Error,
3420 {
3421 match value {
3422 "status" => Ok(GeneratedField::Status),
3423 "version" => Ok(GeneratedField::Version),
3424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3425 }
3426 }
3427 }
3428 deserializer.deserialize_identifier(GeneratedVisitor)
3429 }
3430 }
3431 struct GeneratedVisitor;
3432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3433 type Value = AlterSwapRenameResponse;
3434
3435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3436 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
3437 }
3438
3439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
3440 where
3441 V: serde::de::MapAccess<'de>,
3442 {
3443 let mut status__ = None;
3444 let mut version__ = None;
3445 while let Some(k) = map_.next_key()? {
3446 match k {
3447 GeneratedField::Status => {
3448 if status__.is_some() {
3449 return Err(serde::de::Error::duplicate_field("status"));
3450 }
3451 status__ = map_.next_value()?;
3452 }
3453 GeneratedField::Version => {
3454 if version__.is_some() {
3455 return Err(serde::de::Error::duplicate_field("version"));
3456 }
3457 version__ = map_.next_value()?;
3458 }
3459 }
3460 }
3461 Ok(AlterSwapRenameResponse {
3462 status: status__,
3463 version: version__,
3464 })
3465 }
3466 }
3467 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
3468 }
3469}
3470impl serde::Serialize for AutoSchemaChangeRequest {
3471 #[allow(deprecated)]
3472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3473 where
3474 S: serde::Serializer,
3475 {
3476 use serde::ser::SerializeStruct;
3477 let mut len = 0;
3478 if self.schema_change.is_some() {
3479 len += 1;
3480 }
3481 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
3482 if let Some(v) = self.schema_change.as_ref() {
3483 struct_ser.serialize_field("schemaChange", v)?;
3484 }
3485 struct_ser.end()
3486 }
3487}
3488impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
3489 #[allow(deprecated)]
3490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3491 where
3492 D: serde::Deserializer<'de>,
3493 {
3494 const FIELDS: &[&str] = &[
3495 "schema_change",
3496 "schemaChange",
3497 ];
3498
3499 #[allow(clippy::enum_variant_names)]
3500 enum GeneratedField {
3501 SchemaChange,
3502 }
3503 impl<'de> serde::Deserialize<'de> for GeneratedField {
3504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3505 where
3506 D: serde::Deserializer<'de>,
3507 {
3508 struct GeneratedVisitor;
3509
3510 impl serde::de::Visitor<'_> for GeneratedVisitor {
3511 type Value = GeneratedField;
3512
3513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3514 write!(formatter, "expected one of: {:?}", &FIELDS)
3515 }
3516
3517 #[allow(unused_variables)]
3518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3519 where
3520 E: serde::de::Error,
3521 {
3522 match value {
3523 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
3524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3525 }
3526 }
3527 }
3528 deserializer.deserialize_identifier(GeneratedVisitor)
3529 }
3530 }
3531 struct GeneratedVisitor;
3532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3533 type Value = AutoSchemaChangeRequest;
3534
3535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3536 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
3537 }
3538
3539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
3540 where
3541 V: serde::de::MapAccess<'de>,
3542 {
3543 let mut schema_change__ = None;
3544 while let Some(k) = map_.next_key()? {
3545 match k {
3546 GeneratedField::SchemaChange => {
3547 if schema_change__.is_some() {
3548 return Err(serde::de::Error::duplicate_field("schemaChange"));
3549 }
3550 schema_change__ = map_.next_value()?;
3551 }
3552 }
3553 }
3554 Ok(AutoSchemaChangeRequest {
3555 schema_change: schema_change__,
3556 })
3557 }
3558 }
3559 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
3560 }
3561}
3562impl serde::Serialize for AutoSchemaChangeResponse {
3563 #[allow(deprecated)]
3564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3565 where
3566 S: serde::Serializer,
3567 {
3568 use serde::ser::SerializeStruct;
3569 let len = 0;
3570 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
3571 struct_ser.end()
3572 }
3573}
3574impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
3575 #[allow(deprecated)]
3576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3577 where
3578 D: serde::Deserializer<'de>,
3579 {
3580 const FIELDS: &[&str] = &[
3581 ];
3582
3583 #[allow(clippy::enum_variant_names)]
3584 enum GeneratedField {
3585 }
3586 impl<'de> serde::Deserialize<'de> for GeneratedField {
3587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3588 where
3589 D: serde::Deserializer<'de>,
3590 {
3591 struct GeneratedVisitor;
3592
3593 impl serde::de::Visitor<'_> for GeneratedVisitor {
3594 type Value = GeneratedField;
3595
3596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3597 write!(formatter, "expected one of: {:?}", &FIELDS)
3598 }
3599
3600 #[allow(unused_variables)]
3601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3602 where
3603 E: serde::de::Error,
3604 {
3605 Err(serde::de::Error::unknown_field(value, FIELDS))
3606 }
3607 }
3608 deserializer.deserialize_identifier(GeneratedVisitor)
3609 }
3610 }
3611 struct GeneratedVisitor;
3612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3613 type Value = AutoSchemaChangeResponse;
3614
3615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3616 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
3617 }
3618
3619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
3620 where
3621 V: serde::de::MapAccess<'de>,
3622 {
3623 while map_.next_key::<GeneratedField>()?.is_some() {
3624 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3625 }
3626 Ok(AutoSchemaChangeResponse {
3627 })
3628 }
3629 }
3630 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
3631 }
3632}
3633impl serde::Serialize for BackfillType {
3634 #[allow(deprecated)]
3635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3636 where
3637 S: serde::Serializer,
3638 {
3639 let variant = match self {
3640 Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
3641 Self::NormalBackfill => "NORMAL_BACKFILL",
3642 Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
3643 };
3644 serializer.serialize_str(variant)
3645 }
3646}
3647impl<'de> serde::Deserialize<'de> for BackfillType {
3648 #[allow(deprecated)]
3649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3650 where
3651 D: serde::Deserializer<'de>,
3652 {
3653 const FIELDS: &[&str] = &[
3654 "BACKFILL_TYPE_UNSPECIFIED",
3655 "NORMAL_BACKFILL",
3656 "SNAPSHOT_BACKFILL",
3657 ];
3658
3659 struct GeneratedVisitor;
3660
3661 impl serde::de::Visitor<'_> for GeneratedVisitor {
3662 type Value = BackfillType;
3663
3664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3665 write!(formatter, "expected one of: {:?}", &FIELDS)
3666 }
3667
3668 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3669 where
3670 E: serde::de::Error,
3671 {
3672 i32::try_from(v)
3673 .ok()
3674 .and_then(|x| x.try_into().ok())
3675 .ok_or_else(|| {
3676 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3677 })
3678 }
3679
3680 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3681 where
3682 E: serde::de::Error,
3683 {
3684 i32::try_from(v)
3685 .ok()
3686 .and_then(|x| x.try_into().ok())
3687 .ok_or_else(|| {
3688 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3689 })
3690 }
3691
3692 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3693 where
3694 E: serde::de::Error,
3695 {
3696 match value {
3697 "BACKFILL_TYPE_UNSPECIFIED" => Ok(BackfillType::Unspecified),
3698 "NORMAL_BACKFILL" => Ok(BackfillType::NormalBackfill),
3699 "SNAPSHOT_BACKFILL" => Ok(BackfillType::SnapshotBackfill),
3700 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3701 }
3702 }
3703 }
3704 deserializer.deserialize_any(GeneratedVisitor)
3705 }
3706}
3707impl serde::Serialize for CommentOnRequest {
3708 #[allow(deprecated)]
3709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3710 where
3711 S: serde::Serializer,
3712 {
3713 use serde::ser::SerializeStruct;
3714 let mut len = 0;
3715 if self.comment.is_some() {
3716 len += 1;
3717 }
3718 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
3719 if let Some(v) = self.comment.as_ref() {
3720 struct_ser.serialize_field("comment", v)?;
3721 }
3722 struct_ser.end()
3723 }
3724}
3725impl<'de> serde::Deserialize<'de> for CommentOnRequest {
3726 #[allow(deprecated)]
3727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3728 where
3729 D: serde::Deserializer<'de>,
3730 {
3731 const FIELDS: &[&str] = &[
3732 "comment",
3733 ];
3734
3735 #[allow(clippy::enum_variant_names)]
3736 enum GeneratedField {
3737 Comment,
3738 }
3739 impl<'de> serde::Deserialize<'de> for GeneratedField {
3740 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3741 where
3742 D: serde::Deserializer<'de>,
3743 {
3744 struct GeneratedVisitor;
3745
3746 impl serde::de::Visitor<'_> for GeneratedVisitor {
3747 type Value = GeneratedField;
3748
3749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3750 write!(formatter, "expected one of: {:?}", &FIELDS)
3751 }
3752
3753 #[allow(unused_variables)]
3754 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3755 where
3756 E: serde::de::Error,
3757 {
3758 match value {
3759 "comment" => Ok(GeneratedField::Comment),
3760 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3761 }
3762 }
3763 }
3764 deserializer.deserialize_identifier(GeneratedVisitor)
3765 }
3766 }
3767 struct GeneratedVisitor;
3768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3769 type Value = CommentOnRequest;
3770
3771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3772 formatter.write_str("struct ddl_service.CommentOnRequest")
3773 }
3774
3775 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
3776 where
3777 V: serde::de::MapAccess<'de>,
3778 {
3779 let mut comment__ = None;
3780 while let Some(k) = map_.next_key()? {
3781 match k {
3782 GeneratedField::Comment => {
3783 if comment__.is_some() {
3784 return Err(serde::de::Error::duplicate_field("comment"));
3785 }
3786 comment__ = map_.next_value()?;
3787 }
3788 }
3789 }
3790 Ok(CommentOnRequest {
3791 comment: comment__,
3792 })
3793 }
3794 }
3795 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
3796 }
3797}
3798impl serde::Serialize for CommentOnResponse {
3799 #[allow(deprecated)]
3800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3801 where
3802 S: serde::Serializer,
3803 {
3804 use serde::ser::SerializeStruct;
3805 let mut len = 0;
3806 if self.status.is_some() {
3807 len += 1;
3808 }
3809 if self.version.is_some() {
3810 len += 1;
3811 }
3812 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
3813 if let Some(v) = self.status.as_ref() {
3814 struct_ser.serialize_field("status", v)?;
3815 }
3816 if let Some(v) = self.version.as_ref() {
3817 struct_ser.serialize_field("version", v)?;
3818 }
3819 struct_ser.end()
3820 }
3821}
3822impl<'de> serde::Deserialize<'de> for CommentOnResponse {
3823 #[allow(deprecated)]
3824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3825 where
3826 D: serde::Deserializer<'de>,
3827 {
3828 const FIELDS: &[&str] = &[
3829 "status",
3830 "version",
3831 ];
3832
3833 #[allow(clippy::enum_variant_names)]
3834 enum GeneratedField {
3835 Status,
3836 Version,
3837 }
3838 impl<'de> serde::Deserialize<'de> for GeneratedField {
3839 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3840 where
3841 D: serde::Deserializer<'de>,
3842 {
3843 struct GeneratedVisitor;
3844
3845 impl serde::de::Visitor<'_> for GeneratedVisitor {
3846 type Value = GeneratedField;
3847
3848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3849 write!(formatter, "expected one of: {:?}", &FIELDS)
3850 }
3851
3852 #[allow(unused_variables)]
3853 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3854 where
3855 E: serde::de::Error,
3856 {
3857 match value {
3858 "status" => Ok(GeneratedField::Status),
3859 "version" => Ok(GeneratedField::Version),
3860 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3861 }
3862 }
3863 }
3864 deserializer.deserialize_identifier(GeneratedVisitor)
3865 }
3866 }
3867 struct GeneratedVisitor;
3868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3869 type Value = CommentOnResponse;
3870
3871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3872 formatter.write_str("struct ddl_service.CommentOnResponse")
3873 }
3874
3875 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
3876 where
3877 V: serde::de::MapAccess<'de>,
3878 {
3879 let mut status__ = None;
3880 let mut version__ = None;
3881 while let Some(k) = map_.next_key()? {
3882 match k {
3883 GeneratedField::Status => {
3884 if status__.is_some() {
3885 return Err(serde::de::Error::duplicate_field("status"));
3886 }
3887 status__ = map_.next_value()?;
3888 }
3889 GeneratedField::Version => {
3890 if version__.is_some() {
3891 return Err(serde::de::Error::duplicate_field("version"));
3892 }
3893 version__ = map_.next_value()?;
3894 }
3895 }
3896 }
3897 Ok(CommentOnResponse {
3898 status: status__,
3899 version: version__,
3900 })
3901 }
3902 }
3903 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
3904 }
3905}
3906impl serde::Serialize for CompactIcebergTableRequest {
3907 #[allow(deprecated)]
3908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3909 where
3910 S: serde::Serializer,
3911 {
3912 use serde::ser::SerializeStruct;
3913 let mut len = 0;
3914 if self.sink_id != 0 {
3915 len += 1;
3916 }
3917 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
3918 if self.sink_id != 0 {
3919 struct_ser.serialize_field("sinkId", &self.sink_id)?;
3920 }
3921 struct_ser.end()
3922 }
3923}
3924impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
3925 #[allow(deprecated)]
3926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3927 where
3928 D: serde::Deserializer<'de>,
3929 {
3930 const FIELDS: &[&str] = &[
3931 "sink_id",
3932 "sinkId",
3933 ];
3934
3935 #[allow(clippy::enum_variant_names)]
3936 enum GeneratedField {
3937 SinkId,
3938 }
3939 impl<'de> serde::Deserialize<'de> for GeneratedField {
3940 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3941 where
3942 D: serde::Deserializer<'de>,
3943 {
3944 struct GeneratedVisitor;
3945
3946 impl serde::de::Visitor<'_> for GeneratedVisitor {
3947 type Value = GeneratedField;
3948
3949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3950 write!(formatter, "expected one of: {:?}", &FIELDS)
3951 }
3952
3953 #[allow(unused_variables)]
3954 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3955 where
3956 E: serde::de::Error,
3957 {
3958 match value {
3959 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
3960 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3961 }
3962 }
3963 }
3964 deserializer.deserialize_identifier(GeneratedVisitor)
3965 }
3966 }
3967 struct GeneratedVisitor;
3968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3969 type Value = CompactIcebergTableRequest;
3970
3971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3972 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
3973 }
3974
3975 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
3976 where
3977 V: serde::de::MapAccess<'de>,
3978 {
3979 let mut sink_id__ = None;
3980 while let Some(k) = map_.next_key()? {
3981 match k {
3982 GeneratedField::SinkId => {
3983 if sink_id__.is_some() {
3984 return Err(serde::de::Error::duplicate_field("sinkId"));
3985 }
3986 sink_id__ =
3987 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3988 ;
3989 }
3990 }
3991 }
3992 Ok(CompactIcebergTableRequest {
3993 sink_id: sink_id__.unwrap_or_default(),
3994 })
3995 }
3996 }
3997 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
3998 }
3999}
4000impl serde::Serialize for CompactIcebergTableResponse {
4001 #[allow(deprecated)]
4002 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4003 where
4004 S: serde::Serializer,
4005 {
4006 use serde::ser::SerializeStruct;
4007 let mut len = 0;
4008 if self.status.is_some() {
4009 len += 1;
4010 }
4011 if self.task_id != 0 {
4012 len += 1;
4013 }
4014 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
4015 if let Some(v) = self.status.as_ref() {
4016 struct_ser.serialize_field("status", v)?;
4017 }
4018 if self.task_id != 0 {
4019 #[allow(clippy::needless_borrow)]
4020 #[allow(clippy::needless_borrows_for_generic_args)]
4021 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
4022 }
4023 struct_ser.end()
4024 }
4025}
4026impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
4027 #[allow(deprecated)]
4028 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4029 where
4030 D: serde::Deserializer<'de>,
4031 {
4032 const FIELDS: &[&str] = &[
4033 "status",
4034 "task_id",
4035 "taskId",
4036 ];
4037
4038 #[allow(clippy::enum_variant_names)]
4039 enum GeneratedField {
4040 Status,
4041 TaskId,
4042 }
4043 impl<'de> serde::Deserialize<'de> for GeneratedField {
4044 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4045 where
4046 D: serde::Deserializer<'de>,
4047 {
4048 struct GeneratedVisitor;
4049
4050 impl serde::de::Visitor<'_> for GeneratedVisitor {
4051 type Value = GeneratedField;
4052
4053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4054 write!(formatter, "expected one of: {:?}", &FIELDS)
4055 }
4056
4057 #[allow(unused_variables)]
4058 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4059 where
4060 E: serde::de::Error,
4061 {
4062 match value {
4063 "status" => Ok(GeneratedField::Status),
4064 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
4065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4066 }
4067 }
4068 }
4069 deserializer.deserialize_identifier(GeneratedVisitor)
4070 }
4071 }
4072 struct GeneratedVisitor;
4073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4074 type Value = CompactIcebergTableResponse;
4075
4076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4077 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
4078 }
4079
4080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
4081 where
4082 V: serde::de::MapAccess<'de>,
4083 {
4084 let mut status__ = None;
4085 let mut task_id__ = None;
4086 while let Some(k) = map_.next_key()? {
4087 match k {
4088 GeneratedField::Status => {
4089 if status__.is_some() {
4090 return Err(serde::de::Error::duplicate_field("status"));
4091 }
4092 status__ = map_.next_value()?;
4093 }
4094 GeneratedField::TaskId => {
4095 if task_id__.is_some() {
4096 return Err(serde::de::Error::duplicate_field("taskId"));
4097 }
4098 task_id__ =
4099 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4100 ;
4101 }
4102 }
4103 }
4104 Ok(CompactIcebergTableResponse {
4105 status: status__,
4106 task_id: task_id__.unwrap_or_default(),
4107 })
4108 }
4109 }
4110 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
4111 }
4112}
4113impl serde::Serialize for CreateConnectionRequest {
4114 #[allow(deprecated)]
4115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4116 where
4117 S: serde::Serializer,
4118 {
4119 use serde::ser::SerializeStruct;
4120 let mut len = 0;
4121 if !self.name.is_empty() {
4122 len += 1;
4123 }
4124 if self.database_id != 0 {
4125 len += 1;
4126 }
4127 if self.schema_id != 0 {
4128 len += 1;
4129 }
4130 if self.owner_id != 0 {
4131 len += 1;
4132 }
4133 if self.payload.is_some() {
4134 len += 1;
4135 }
4136 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
4137 if !self.name.is_empty() {
4138 struct_ser.serialize_field("name", &self.name)?;
4139 }
4140 if self.database_id != 0 {
4141 struct_ser.serialize_field("databaseId", &self.database_id)?;
4142 }
4143 if self.schema_id != 0 {
4144 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4145 }
4146 if self.owner_id != 0 {
4147 struct_ser.serialize_field("ownerId", &self.owner_id)?;
4148 }
4149 if let Some(v) = self.payload.as_ref() {
4150 match v {
4151 create_connection_request::Payload::PrivateLink(v) => {
4152 struct_ser.serialize_field("privateLink", v)?;
4153 }
4154 create_connection_request::Payload::ConnectionParams(v) => {
4155 struct_ser.serialize_field("connectionParams", v)?;
4156 }
4157 }
4158 }
4159 struct_ser.end()
4160 }
4161}
4162impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
4163 #[allow(deprecated)]
4164 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4165 where
4166 D: serde::Deserializer<'de>,
4167 {
4168 const FIELDS: &[&str] = &[
4169 "name",
4170 "database_id",
4171 "databaseId",
4172 "schema_id",
4173 "schemaId",
4174 "owner_id",
4175 "ownerId",
4176 "private_link",
4177 "privateLink",
4178 "connection_params",
4179 "connectionParams",
4180 ];
4181
4182 #[allow(clippy::enum_variant_names)]
4183 enum GeneratedField {
4184 Name,
4185 DatabaseId,
4186 SchemaId,
4187 OwnerId,
4188 PrivateLink,
4189 ConnectionParams,
4190 }
4191 impl<'de> serde::Deserialize<'de> for GeneratedField {
4192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4193 where
4194 D: serde::Deserializer<'de>,
4195 {
4196 struct GeneratedVisitor;
4197
4198 impl serde::de::Visitor<'_> for GeneratedVisitor {
4199 type Value = GeneratedField;
4200
4201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4202 write!(formatter, "expected one of: {:?}", &FIELDS)
4203 }
4204
4205 #[allow(unused_variables)]
4206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4207 where
4208 E: serde::de::Error,
4209 {
4210 match value {
4211 "name" => Ok(GeneratedField::Name),
4212 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4213 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4214 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
4215 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
4216 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
4217 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4218 }
4219 }
4220 }
4221 deserializer.deserialize_identifier(GeneratedVisitor)
4222 }
4223 }
4224 struct GeneratedVisitor;
4225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4226 type Value = CreateConnectionRequest;
4227
4228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4229 formatter.write_str("struct ddl_service.CreateConnectionRequest")
4230 }
4231
4232 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
4233 where
4234 V: serde::de::MapAccess<'de>,
4235 {
4236 let mut name__ = None;
4237 let mut database_id__ = None;
4238 let mut schema_id__ = None;
4239 let mut owner_id__ = None;
4240 let mut payload__ = None;
4241 while let Some(k) = map_.next_key()? {
4242 match k {
4243 GeneratedField::Name => {
4244 if name__.is_some() {
4245 return Err(serde::de::Error::duplicate_field("name"));
4246 }
4247 name__ = Some(map_.next_value()?);
4248 }
4249 GeneratedField::DatabaseId => {
4250 if database_id__.is_some() {
4251 return Err(serde::de::Error::duplicate_field("databaseId"));
4252 }
4253 database_id__ =
4254 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4255 ;
4256 }
4257 GeneratedField::SchemaId => {
4258 if schema_id__.is_some() {
4259 return Err(serde::de::Error::duplicate_field("schemaId"));
4260 }
4261 schema_id__ =
4262 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4263 ;
4264 }
4265 GeneratedField::OwnerId => {
4266 if owner_id__.is_some() {
4267 return Err(serde::de::Error::duplicate_field("ownerId"));
4268 }
4269 owner_id__ =
4270 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4271 ;
4272 }
4273 GeneratedField::PrivateLink => {
4274 if payload__.is_some() {
4275 return Err(serde::de::Error::duplicate_field("privateLink"));
4276 }
4277 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
4278;
4279 }
4280 GeneratedField::ConnectionParams => {
4281 if payload__.is_some() {
4282 return Err(serde::de::Error::duplicate_field("connectionParams"));
4283 }
4284 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
4285;
4286 }
4287 }
4288 }
4289 Ok(CreateConnectionRequest {
4290 name: name__.unwrap_or_default(),
4291 database_id: database_id__.unwrap_or_default(),
4292 schema_id: schema_id__.unwrap_or_default(),
4293 owner_id: owner_id__.unwrap_or_default(),
4294 payload: payload__,
4295 })
4296 }
4297 }
4298 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
4299 }
4300}
4301impl serde::Serialize for create_connection_request::PrivateLink {
4302 #[allow(deprecated)]
4303 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4304 where
4305 S: serde::Serializer,
4306 {
4307 use serde::ser::SerializeStruct;
4308 let mut len = 0;
4309 if self.provider != 0 {
4310 len += 1;
4311 }
4312 if !self.service_name.is_empty() {
4313 len += 1;
4314 }
4315 if self.tags.is_some() {
4316 len += 1;
4317 }
4318 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
4319 if self.provider != 0 {
4320 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
4321 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
4322 struct_ser.serialize_field("provider", &v)?;
4323 }
4324 if !self.service_name.is_empty() {
4325 struct_ser.serialize_field("serviceName", &self.service_name)?;
4326 }
4327 if let Some(v) = self.tags.as_ref() {
4328 struct_ser.serialize_field("tags", v)?;
4329 }
4330 struct_ser.end()
4331 }
4332}
4333impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
4334 #[allow(deprecated)]
4335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4336 where
4337 D: serde::Deserializer<'de>,
4338 {
4339 const FIELDS: &[&str] = &[
4340 "provider",
4341 "service_name",
4342 "serviceName",
4343 "tags",
4344 ];
4345
4346 #[allow(clippy::enum_variant_names)]
4347 enum GeneratedField {
4348 Provider,
4349 ServiceName,
4350 Tags,
4351 }
4352 impl<'de> serde::Deserialize<'de> for GeneratedField {
4353 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4354 where
4355 D: serde::Deserializer<'de>,
4356 {
4357 struct GeneratedVisitor;
4358
4359 impl serde::de::Visitor<'_> for GeneratedVisitor {
4360 type Value = GeneratedField;
4361
4362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4363 write!(formatter, "expected one of: {:?}", &FIELDS)
4364 }
4365
4366 #[allow(unused_variables)]
4367 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4368 where
4369 E: serde::de::Error,
4370 {
4371 match value {
4372 "provider" => Ok(GeneratedField::Provider),
4373 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
4374 "tags" => Ok(GeneratedField::Tags),
4375 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4376 }
4377 }
4378 }
4379 deserializer.deserialize_identifier(GeneratedVisitor)
4380 }
4381 }
4382 struct GeneratedVisitor;
4383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4384 type Value = create_connection_request::PrivateLink;
4385
4386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4387 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
4388 }
4389
4390 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
4391 where
4392 V: serde::de::MapAccess<'de>,
4393 {
4394 let mut provider__ = None;
4395 let mut service_name__ = None;
4396 let mut tags__ = None;
4397 while let Some(k) = map_.next_key()? {
4398 match k {
4399 GeneratedField::Provider => {
4400 if provider__.is_some() {
4401 return Err(serde::de::Error::duplicate_field("provider"));
4402 }
4403 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
4404 }
4405 GeneratedField::ServiceName => {
4406 if service_name__.is_some() {
4407 return Err(serde::de::Error::duplicate_field("serviceName"));
4408 }
4409 service_name__ = Some(map_.next_value()?);
4410 }
4411 GeneratedField::Tags => {
4412 if tags__.is_some() {
4413 return Err(serde::de::Error::duplicate_field("tags"));
4414 }
4415 tags__ = map_.next_value()?;
4416 }
4417 }
4418 }
4419 Ok(create_connection_request::PrivateLink {
4420 provider: provider__.unwrap_or_default(),
4421 service_name: service_name__.unwrap_or_default(),
4422 tags: tags__,
4423 })
4424 }
4425 }
4426 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
4427 }
4428}
4429impl serde::Serialize for CreateConnectionResponse {
4430 #[allow(deprecated)]
4431 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4432 where
4433 S: serde::Serializer,
4434 {
4435 use serde::ser::SerializeStruct;
4436 let mut len = 0;
4437 if self.version.is_some() {
4438 len += 1;
4439 }
4440 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
4441 if let Some(v) = self.version.as_ref() {
4442 struct_ser.serialize_field("version", v)?;
4443 }
4444 struct_ser.end()
4445 }
4446}
4447impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
4448 #[allow(deprecated)]
4449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4450 where
4451 D: serde::Deserializer<'de>,
4452 {
4453 const FIELDS: &[&str] = &[
4454 "version",
4455 ];
4456
4457 #[allow(clippy::enum_variant_names)]
4458 enum GeneratedField {
4459 Version,
4460 }
4461 impl<'de> serde::Deserialize<'de> for GeneratedField {
4462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4463 where
4464 D: serde::Deserializer<'de>,
4465 {
4466 struct GeneratedVisitor;
4467
4468 impl serde::de::Visitor<'_> for GeneratedVisitor {
4469 type Value = GeneratedField;
4470
4471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4472 write!(formatter, "expected one of: {:?}", &FIELDS)
4473 }
4474
4475 #[allow(unused_variables)]
4476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4477 where
4478 E: serde::de::Error,
4479 {
4480 match value {
4481 "version" => Ok(GeneratedField::Version),
4482 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4483 }
4484 }
4485 }
4486 deserializer.deserialize_identifier(GeneratedVisitor)
4487 }
4488 }
4489 struct GeneratedVisitor;
4490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4491 type Value = CreateConnectionResponse;
4492
4493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4494 formatter.write_str("struct ddl_service.CreateConnectionResponse")
4495 }
4496
4497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
4498 where
4499 V: serde::de::MapAccess<'de>,
4500 {
4501 let mut version__ = None;
4502 while let Some(k) = map_.next_key()? {
4503 match k {
4504 GeneratedField::Version => {
4505 if version__.is_some() {
4506 return Err(serde::de::Error::duplicate_field("version"));
4507 }
4508 version__ = map_.next_value()?;
4509 }
4510 }
4511 }
4512 Ok(CreateConnectionResponse {
4513 version: version__,
4514 })
4515 }
4516 }
4517 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
4518 }
4519}
4520impl serde::Serialize for CreateDatabaseRequest {
4521 #[allow(deprecated)]
4522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4523 where
4524 S: serde::Serializer,
4525 {
4526 use serde::ser::SerializeStruct;
4527 let mut len = 0;
4528 if self.db.is_some() {
4529 len += 1;
4530 }
4531 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
4532 if let Some(v) = self.db.as_ref() {
4533 struct_ser.serialize_field("db", v)?;
4534 }
4535 struct_ser.end()
4536 }
4537}
4538impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
4539 #[allow(deprecated)]
4540 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4541 where
4542 D: serde::Deserializer<'de>,
4543 {
4544 const FIELDS: &[&str] = &[
4545 "db",
4546 ];
4547
4548 #[allow(clippy::enum_variant_names)]
4549 enum GeneratedField {
4550 Db,
4551 }
4552 impl<'de> serde::Deserialize<'de> for GeneratedField {
4553 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4554 where
4555 D: serde::Deserializer<'de>,
4556 {
4557 struct GeneratedVisitor;
4558
4559 impl serde::de::Visitor<'_> for GeneratedVisitor {
4560 type Value = GeneratedField;
4561
4562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4563 write!(formatter, "expected one of: {:?}", &FIELDS)
4564 }
4565
4566 #[allow(unused_variables)]
4567 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4568 where
4569 E: serde::de::Error,
4570 {
4571 match value {
4572 "db" => Ok(GeneratedField::Db),
4573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4574 }
4575 }
4576 }
4577 deserializer.deserialize_identifier(GeneratedVisitor)
4578 }
4579 }
4580 struct GeneratedVisitor;
4581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4582 type Value = CreateDatabaseRequest;
4583
4584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4585 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
4586 }
4587
4588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
4589 where
4590 V: serde::de::MapAccess<'de>,
4591 {
4592 let mut db__ = None;
4593 while let Some(k) = map_.next_key()? {
4594 match k {
4595 GeneratedField::Db => {
4596 if db__.is_some() {
4597 return Err(serde::de::Error::duplicate_field("db"));
4598 }
4599 db__ = map_.next_value()?;
4600 }
4601 }
4602 }
4603 Ok(CreateDatabaseRequest {
4604 db: db__,
4605 })
4606 }
4607 }
4608 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
4609 }
4610}
4611impl serde::Serialize for CreateDatabaseResponse {
4612 #[allow(deprecated)]
4613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4614 where
4615 S: serde::Serializer,
4616 {
4617 use serde::ser::SerializeStruct;
4618 let mut len = 0;
4619 if self.status.is_some() {
4620 len += 1;
4621 }
4622 if self.version.is_some() {
4623 len += 1;
4624 }
4625 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
4626 if let Some(v) = self.status.as_ref() {
4627 struct_ser.serialize_field("status", v)?;
4628 }
4629 if let Some(v) = self.version.as_ref() {
4630 struct_ser.serialize_field("version", v)?;
4631 }
4632 struct_ser.end()
4633 }
4634}
4635impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
4636 #[allow(deprecated)]
4637 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4638 where
4639 D: serde::Deserializer<'de>,
4640 {
4641 const FIELDS: &[&str] = &[
4642 "status",
4643 "version",
4644 ];
4645
4646 #[allow(clippy::enum_variant_names)]
4647 enum GeneratedField {
4648 Status,
4649 Version,
4650 }
4651 impl<'de> serde::Deserialize<'de> for GeneratedField {
4652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4653 where
4654 D: serde::Deserializer<'de>,
4655 {
4656 struct GeneratedVisitor;
4657
4658 impl serde::de::Visitor<'_> for GeneratedVisitor {
4659 type Value = GeneratedField;
4660
4661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4662 write!(formatter, "expected one of: {:?}", &FIELDS)
4663 }
4664
4665 #[allow(unused_variables)]
4666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4667 where
4668 E: serde::de::Error,
4669 {
4670 match value {
4671 "status" => Ok(GeneratedField::Status),
4672 "version" => Ok(GeneratedField::Version),
4673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4674 }
4675 }
4676 }
4677 deserializer.deserialize_identifier(GeneratedVisitor)
4678 }
4679 }
4680 struct GeneratedVisitor;
4681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4682 type Value = CreateDatabaseResponse;
4683
4684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4685 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
4686 }
4687
4688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
4689 where
4690 V: serde::de::MapAccess<'de>,
4691 {
4692 let mut status__ = None;
4693 let mut version__ = None;
4694 while let Some(k) = map_.next_key()? {
4695 match k {
4696 GeneratedField::Status => {
4697 if status__.is_some() {
4698 return Err(serde::de::Error::duplicate_field("status"));
4699 }
4700 status__ = map_.next_value()?;
4701 }
4702 GeneratedField::Version => {
4703 if version__.is_some() {
4704 return Err(serde::de::Error::duplicate_field("version"));
4705 }
4706 version__ = map_.next_value()?;
4707 }
4708 }
4709 }
4710 Ok(CreateDatabaseResponse {
4711 status: status__,
4712 version: version__,
4713 })
4714 }
4715 }
4716 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
4717 }
4718}
4719impl serde::Serialize for CreateFunctionRequest {
4720 #[allow(deprecated)]
4721 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4722 where
4723 S: serde::Serializer,
4724 {
4725 use serde::ser::SerializeStruct;
4726 let mut len = 0;
4727 if self.function.is_some() {
4728 len += 1;
4729 }
4730 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
4731 if let Some(v) = self.function.as_ref() {
4732 struct_ser.serialize_field("function", v)?;
4733 }
4734 struct_ser.end()
4735 }
4736}
4737impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
4738 #[allow(deprecated)]
4739 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4740 where
4741 D: serde::Deserializer<'de>,
4742 {
4743 const FIELDS: &[&str] = &[
4744 "function",
4745 ];
4746
4747 #[allow(clippy::enum_variant_names)]
4748 enum GeneratedField {
4749 Function,
4750 }
4751 impl<'de> serde::Deserialize<'de> for GeneratedField {
4752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4753 where
4754 D: serde::Deserializer<'de>,
4755 {
4756 struct GeneratedVisitor;
4757
4758 impl serde::de::Visitor<'_> for GeneratedVisitor {
4759 type Value = GeneratedField;
4760
4761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4762 write!(formatter, "expected one of: {:?}", &FIELDS)
4763 }
4764
4765 #[allow(unused_variables)]
4766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4767 where
4768 E: serde::de::Error,
4769 {
4770 match value {
4771 "function" => Ok(GeneratedField::Function),
4772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4773 }
4774 }
4775 }
4776 deserializer.deserialize_identifier(GeneratedVisitor)
4777 }
4778 }
4779 struct GeneratedVisitor;
4780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4781 type Value = CreateFunctionRequest;
4782
4783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4784 formatter.write_str("struct ddl_service.CreateFunctionRequest")
4785 }
4786
4787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
4788 where
4789 V: serde::de::MapAccess<'de>,
4790 {
4791 let mut function__ = None;
4792 while let Some(k) = map_.next_key()? {
4793 match k {
4794 GeneratedField::Function => {
4795 if function__.is_some() {
4796 return Err(serde::de::Error::duplicate_field("function"));
4797 }
4798 function__ = map_.next_value()?;
4799 }
4800 }
4801 }
4802 Ok(CreateFunctionRequest {
4803 function: function__,
4804 })
4805 }
4806 }
4807 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
4808 }
4809}
4810impl serde::Serialize for CreateFunctionResponse {
4811 #[allow(deprecated)]
4812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4813 where
4814 S: serde::Serializer,
4815 {
4816 use serde::ser::SerializeStruct;
4817 let mut len = 0;
4818 if self.status.is_some() {
4819 len += 1;
4820 }
4821 if self.version.is_some() {
4822 len += 1;
4823 }
4824 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
4825 if let Some(v) = self.status.as_ref() {
4826 struct_ser.serialize_field("status", v)?;
4827 }
4828 if let Some(v) = self.version.as_ref() {
4829 struct_ser.serialize_field("version", v)?;
4830 }
4831 struct_ser.end()
4832 }
4833}
4834impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
4835 #[allow(deprecated)]
4836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4837 where
4838 D: serde::Deserializer<'de>,
4839 {
4840 const FIELDS: &[&str] = &[
4841 "status",
4842 "version",
4843 ];
4844
4845 #[allow(clippy::enum_variant_names)]
4846 enum GeneratedField {
4847 Status,
4848 Version,
4849 }
4850 impl<'de> serde::Deserialize<'de> for GeneratedField {
4851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4852 where
4853 D: serde::Deserializer<'de>,
4854 {
4855 struct GeneratedVisitor;
4856
4857 impl serde::de::Visitor<'_> for GeneratedVisitor {
4858 type Value = GeneratedField;
4859
4860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4861 write!(formatter, "expected one of: {:?}", &FIELDS)
4862 }
4863
4864 #[allow(unused_variables)]
4865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4866 where
4867 E: serde::de::Error,
4868 {
4869 match value {
4870 "status" => Ok(GeneratedField::Status),
4871 "version" => Ok(GeneratedField::Version),
4872 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4873 }
4874 }
4875 }
4876 deserializer.deserialize_identifier(GeneratedVisitor)
4877 }
4878 }
4879 struct GeneratedVisitor;
4880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4881 type Value = CreateFunctionResponse;
4882
4883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4884 formatter.write_str("struct ddl_service.CreateFunctionResponse")
4885 }
4886
4887 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
4888 where
4889 V: serde::de::MapAccess<'de>,
4890 {
4891 let mut status__ = None;
4892 let mut version__ = None;
4893 while let Some(k) = map_.next_key()? {
4894 match k {
4895 GeneratedField::Status => {
4896 if status__.is_some() {
4897 return Err(serde::de::Error::duplicate_field("status"));
4898 }
4899 status__ = map_.next_value()?;
4900 }
4901 GeneratedField::Version => {
4902 if version__.is_some() {
4903 return Err(serde::de::Error::duplicate_field("version"));
4904 }
4905 version__ = map_.next_value()?;
4906 }
4907 }
4908 }
4909 Ok(CreateFunctionResponse {
4910 status: status__,
4911 version: version__,
4912 })
4913 }
4914 }
4915 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
4916 }
4917}
4918impl serde::Serialize for CreateIcebergTableRequest {
4919 #[allow(deprecated)]
4920 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4921 where
4922 S: serde::Serializer,
4923 {
4924 use serde::ser::SerializeStruct;
4925 let mut len = 0;
4926 if self.table_info.is_some() {
4927 len += 1;
4928 }
4929 if self.sink_info.is_some() {
4930 len += 1;
4931 }
4932 if self.iceberg_source.is_some() {
4933 len += 1;
4934 }
4935 if self.if_not_exists {
4936 len += 1;
4937 }
4938 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
4939 if let Some(v) = self.table_info.as_ref() {
4940 struct_ser.serialize_field("tableInfo", v)?;
4941 }
4942 if let Some(v) = self.sink_info.as_ref() {
4943 struct_ser.serialize_field("sinkInfo", v)?;
4944 }
4945 if let Some(v) = self.iceberg_source.as_ref() {
4946 struct_ser.serialize_field("icebergSource", v)?;
4947 }
4948 if self.if_not_exists {
4949 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4950 }
4951 struct_ser.end()
4952 }
4953}
4954impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
4955 #[allow(deprecated)]
4956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4957 where
4958 D: serde::Deserializer<'de>,
4959 {
4960 const FIELDS: &[&str] = &[
4961 "table_info",
4962 "tableInfo",
4963 "sink_info",
4964 "sinkInfo",
4965 "iceberg_source",
4966 "icebergSource",
4967 "if_not_exists",
4968 "ifNotExists",
4969 ];
4970
4971 #[allow(clippy::enum_variant_names)]
4972 enum GeneratedField {
4973 TableInfo,
4974 SinkInfo,
4975 IcebergSource,
4976 IfNotExists,
4977 }
4978 impl<'de> serde::Deserialize<'de> for GeneratedField {
4979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4980 where
4981 D: serde::Deserializer<'de>,
4982 {
4983 struct GeneratedVisitor;
4984
4985 impl serde::de::Visitor<'_> for GeneratedVisitor {
4986 type Value = GeneratedField;
4987
4988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4989 write!(formatter, "expected one of: {:?}", &FIELDS)
4990 }
4991
4992 #[allow(unused_variables)]
4993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4994 where
4995 E: serde::de::Error,
4996 {
4997 match value {
4998 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
4999 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
5000 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
5001 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5003 }
5004 }
5005 }
5006 deserializer.deserialize_identifier(GeneratedVisitor)
5007 }
5008 }
5009 struct GeneratedVisitor;
5010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5011 type Value = CreateIcebergTableRequest;
5012
5013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5014 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
5015 }
5016
5017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
5018 where
5019 V: serde::de::MapAccess<'de>,
5020 {
5021 let mut table_info__ = None;
5022 let mut sink_info__ = None;
5023 let mut iceberg_source__ = None;
5024 let mut if_not_exists__ = None;
5025 while let Some(k) = map_.next_key()? {
5026 match k {
5027 GeneratedField::TableInfo => {
5028 if table_info__.is_some() {
5029 return Err(serde::de::Error::duplicate_field("tableInfo"));
5030 }
5031 table_info__ = map_.next_value()?;
5032 }
5033 GeneratedField::SinkInfo => {
5034 if sink_info__.is_some() {
5035 return Err(serde::de::Error::duplicate_field("sinkInfo"));
5036 }
5037 sink_info__ = map_.next_value()?;
5038 }
5039 GeneratedField::IcebergSource => {
5040 if iceberg_source__.is_some() {
5041 return Err(serde::de::Error::duplicate_field("icebergSource"));
5042 }
5043 iceberg_source__ = map_.next_value()?;
5044 }
5045 GeneratedField::IfNotExists => {
5046 if if_not_exists__.is_some() {
5047 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5048 }
5049 if_not_exists__ = Some(map_.next_value()?);
5050 }
5051 }
5052 }
5053 Ok(CreateIcebergTableRequest {
5054 table_info: table_info__,
5055 sink_info: sink_info__,
5056 iceberg_source: iceberg_source__,
5057 if_not_exists: if_not_exists__.unwrap_or_default(),
5058 })
5059 }
5060 }
5061 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
5062 }
5063}
5064impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
5065 #[allow(deprecated)]
5066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5067 where
5068 S: serde::Serializer,
5069 {
5070 use serde::ser::SerializeStruct;
5071 let mut len = 0;
5072 if self.sink.is_some() {
5073 len += 1;
5074 }
5075 if self.fragment_graph.is_some() {
5076 len += 1;
5077 }
5078 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
5079 if let Some(v) = self.sink.as_ref() {
5080 struct_ser.serialize_field("sink", v)?;
5081 }
5082 if let Some(v) = self.fragment_graph.as_ref() {
5083 struct_ser.serialize_field("fragmentGraph", v)?;
5084 }
5085 struct_ser.end()
5086 }
5087}
5088impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
5089 #[allow(deprecated)]
5090 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5091 where
5092 D: serde::Deserializer<'de>,
5093 {
5094 const FIELDS: &[&str] = &[
5095 "sink",
5096 "fragment_graph",
5097 "fragmentGraph",
5098 ];
5099
5100 #[allow(clippy::enum_variant_names)]
5101 enum GeneratedField {
5102 Sink,
5103 FragmentGraph,
5104 }
5105 impl<'de> serde::Deserialize<'de> for GeneratedField {
5106 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5107 where
5108 D: serde::Deserializer<'de>,
5109 {
5110 struct GeneratedVisitor;
5111
5112 impl serde::de::Visitor<'_> for GeneratedVisitor {
5113 type Value = GeneratedField;
5114
5115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5116 write!(formatter, "expected one of: {:?}", &FIELDS)
5117 }
5118
5119 #[allow(unused_variables)]
5120 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5121 where
5122 E: serde::de::Error,
5123 {
5124 match value {
5125 "sink" => Ok(GeneratedField::Sink),
5126 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5127 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5128 }
5129 }
5130 }
5131 deserializer.deserialize_identifier(GeneratedVisitor)
5132 }
5133 }
5134 struct GeneratedVisitor;
5135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5136 type Value = create_iceberg_table_request::SinkJobInfo;
5137
5138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5139 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
5140 }
5141
5142 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
5143 where
5144 V: serde::de::MapAccess<'de>,
5145 {
5146 let mut sink__ = None;
5147 let mut fragment_graph__ = None;
5148 while let Some(k) = map_.next_key()? {
5149 match k {
5150 GeneratedField::Sink => {
5151 if sink__.is_some() {
5152 return Err(serde::de::Error::duplicate_field("sink"));
5153 }
5154 sink__ = map_.next_value()?;
5155 }
5156 GeneratedField::FragmentGraph => {
5157 if fragment_graph__.is_some() {
5158 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5159 }
5160 fragment_graph__ = map_.next_value()?;
5161 }
5162 }
5163 }
5164 Ok(create_iceberg_table_request::SinkJobInfo {
5165 sink: sink__,
5166 fragment_graph: fragment_graph__,
5167 })
5168 }
5169 }
5170 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
5171 }
5172}
5173impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
5174 #[allow(deprecated)]
5175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5176 where
5177 S: serde::Serializer,
5178 {
5179 use serde::ser::SerializeStruct;
5180 let mut len = 0;
5181 if self.source.is_some() {
5182 len += 1;
5183 }
5184 if self.table.is_some() {
5185 len += 1;
5186 }
5187 if self.fragment_graph.is_some() {
5188 len += 1;
5189 }
5190 if self.job_type != 0 {
5191 len += 1;
5192 }
5193 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
5194 if let Some(v) = self.source.as_ref() {
5195 struct_ser.serialize_field("source", v)?;
5196 }
5197 if let Some(v) = self.table.as_ref() {
5198 struct_ser.serialize_field("table", v)?;
5199 }
5200 if let Some(v) = self.fragment_graph.as_ref() {
5201 struct_ser.serialize_field("fragmentGraph", v)?;
5202 }
5203 if self.job_type != 0 {
5204 let v = TableJobType::try_from(self.job_type)
5205 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
5206 struct_ser.serialize_field("jobType", &v)?;
5207 }
5208 struct_ser.end()
5209 }
5210}
5211impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
5212 #[allow(deprecated)]
5213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5214 where
5215 D: serde::Deserializer<'de>,
5216 {
5217 const FIELDS: &[&str] = &[
5218 "source",
5219 "table",
5220 "fragment_graph",
5221 "fragmentGraph",
5222 "job_type",
5223 "jobType",
5224 ];
5225
5226 #[allow(clippy::enum_variant_names)]
5227 enum GeneratedField {
5228 Source,
5229 Table,
5230 FragmentGraph,
5231 JobType,
5232 }
5233 impl<'de> serde::Deserialize<'de> for GeneratedField {
5234 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5235 where
5236 D: serde::Deserializer<'de>,
5237 {
5238 struct GeneratedVisitor;
5239
5240 impl serde::de::Visitor<'_> for GeneratedVisitor {
5241 type Value = GeneratedField;
5242
5243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5244 write!(formatter, "expected one of: {:?}", &FIELDS)
5245 }
5246
5247 #[allow(unused_variables)]
5248 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5249 where
5250 E: serde::de::Error,
5251 {
5252 match value {
5253 "source" => Ok(GeneratedField::Source),
5254 "table" => Ok(GeneratedField::Table),
5255 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5256 "jobType" | "job_type" => Ok(GeneratedField::JobType),
5257 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5258 }
5259 }
5260 }
5261 deserializer.deserialize_identifier(GeneratedVisitor)
5262 }
5263 }
5264 struct GeneratedVisitor;
5265 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5266 type Value = create_iceberg_table_request::TableJobInfo;
5267
5268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5269 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
5270 }
5271
5272 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
5273 where
5274 V: serde::de::MapAccess<'de>,
5275 {
5276 let mut source__ = None;
5277 let mut table__ = None;
5278 let mut fragment_graph__ = None;
5279 let mut job_type__ = None;
5280 while let Some(k) = map_.next_key()? {
5281 match k {
5282 GeneratedField::Source => {
5283 if source__.is_some() {
5284 return Err(serde::de::Error::duplicate_field("source"));
5285 }
5286 source__ = map_.next_value()?;
5287 }
5288 GeneratedField::Table => {
5289 if table__.is_some() {
5290 return Err(serde::de::Error::duplicate_field("table"));
5291 }
5292 table__ = map_.next_value()?;
5293 }
5294 GeneratedField::FragmentGraph => {
5295 if fragment_graph__.is_some() {
5296 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5297 }
5298 fragment_graph__ = map_.next_value()?;
5299 }
5300 GeneratedField::JobType => {
5301 if job_type__.is_some() {
5302 return Err(serde::de::Error::duplicate_field("jobType"));
5303 }
5304 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
5305 }
5306 }
5307 }
5308 Ok(create_iceberg_table_request::TableJobInfo {
5309 source: source__,
5310 table: table__,
5311 fragment_graph: fragment_graph__,
5312 job_type: job_type__.unwrap_or_default(),
5313 })
5314 }
5315 }
5316 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
5317 }
5318}
5319impl serde::Serialize for CreateIcebergTableResponse {
5320 #[allow(deprecated)]
5321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5322 where
5323 S: serde::Serializer,
5324 {
5325 use serde::ser::SerializeStruct;
5326 let mut len = 0;
5327 if self.status.is_some() {
5328 len += 1;
5329 }
5330 if self.version.is_some() {
5331 len += 1;
5332 }
5333 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
5334 if let Some(v) = self.status.as_ref() {
5335 struct_ser.serialize_field("status", v)?;
5336 }
5337 if let Some(v) = self.version.as_ref() {
5338 struct_ser.serialize_field("version", v)?;
5339 }
5340 struct_ser.end()
5341 }
5342}
5343impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
5344 #[allow(deprecated)]
5345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5346 where
5347 D: serde::Deserializer<'de>,
5348 {
5349 const FIELDS: &[&str] = &[
5350 "status",
5351 "version",
5352 ];
5353
5354 #[allow(clippy::enum_variant_names)]
5355 enum GeneratedField {
5356 Status,
5357 Version,
5358 }
5359 impl<'de> serde::Deserialize<'de> for GeneratedField {
5360 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5361 where
5362 D: serde::Deserializer<'de>,
5363 {
5364 struct GeneratedVisitor;
5365
5366 impl serde::de::Visitor<'_> for GeneratedVisitor {
5367 type Value = GeneratedField;
5368
5369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5370 write!(formatter, "expected one of: {:?}", &FIELDS)
5371 }
5372
5373 #[allow(unused_variables)]
5374 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5375 where
5376 E: serde::de::Error,
5377 {
5378 match value {
5379 "status" => Ok(GeneratedField::Status),
5380 "version" => Ok(GeneratedField::Version),
5381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5382 }
5383 }
5384 }
5385 deserializer.deserialize_identifier(GeneratedVisitor)
5386 }
5387 }
5388 struct GeneratedVisitor;
5389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5390 type Value = CreateIcebergTableResponse;
5391
5392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5393 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
5394 }
5395
5396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
5397 where
5398 V: serde::de::MapAccess<'de>,
5399 {
5400 let mut status__ = None;
5401 let mut version__ = None;
5402 while let Some(k) = map_.next_key()? {
5403 match k {
5404 GeneratedField::Status => {
5405 if status__.is_some() {
5406 return Err(serde::de::Error::duplicate_field("status"));
5407 }
5408 status__ = map_.next_value()?;
5409 }
5410 GeneratedField::Version => {
5411 if version__.is_some() {
5412 return Err(serde::de::Error::duplicate_field("version"));
5413 }
5414 version__ = map_.next_value()?;
5415 }
5416 }
5417 }
5418 Ok(CreateIcebergTableResponse {
5419 status: status__,
5420 version: version__,
5421 })
5422 }
5423 }
5424 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
5425 }
5426}
5427impl serde::Serialize for CreateIndexRequest {
5428 #[allow(deprecated)]
5429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5430 where
5431 S: serde::Serializer,
5432 {
5433 use serde::ser::SerializeStruct;
5434 let mut len = 0;
5435 if self.index.is_some() {
5436 len += 1;
5437 }
5438 if self.index_table.is_some() {
5439 len += 1;
5440 }
5441 if self.fragment_graph.is_some() {
5442 len += 1;
5443 }
5444 if self.if_not_exists {
5445 len += 1;
5446 }
5447 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
5448 if let Some(v) = self.index.as_ref() {
5449 struct_ser.serialize_field("index", v)?;
5450 }
5451 if let Some(v) = self.index_table.as_ref() {
5452 struct_ser.serialize_field("indexTable", v)?;
5453 }
5454 if let Some(v) = self.fragment_graph.as_ref() {
5455 struct_ser.serialize_field("fragmentGraph", v)?;
5456 }
5457 if self.if_not_exists {
5458 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5459 }
5460 struct_ser.end()
5461 }
5462}
5463impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
5464 #[allow(deprecated)]
5465 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5466 where
5467 D: serde::Deserializer<'de>,
5468 {
5469 const FIELDS: &[&str] = &[
5470 "index",
5471 "index_table",
5472 "indexTable",
5473 "fragment_graph",
5474 "fragmentGraph",
5475 "if_not_exists",
5476 "ifNotExists",
5477 ];
5478
5479 #[allow(clippy::enum_variant_names)]
5480 enum GeneratedField {
5481 Index,
5482 IndexTable,
5483 FragmentGraph,
5484 IfNotExists,
5485 }
5486 impl<'de> serde::Deserialize<'de> for GeneratedField {
5487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5488 where
5489 D: serde::Deserializer<'de>,
5490 {
5491 struct GeneratedVisitor;
5492
5493 impl serde::de::Visitor<'_> for GeneratedVisitor {
5494 type Value = GeneratedField;
5495
5496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5497 write!(formatter, "expected one of: {:?}", &FIELDS)
5498 }
5499
5500 #[allow(unused_variables)]
5501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5502 where
5503 E: serde::de::Error,
5504 {
5505 match value {
5506 "index" => Ok(GeneratedField::Index),
5507 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
5508 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5509 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5511 }
5512 }
5513 }
5514 deserializer.deserialize_identifier(GeneratedVisitor)
5515 }
5516 }
5517 struct GeneratedVisitor;
5518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5519 type Value = CreateIndexRequest;
5520
5521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5522 formatter.write_str("struct ddl_service.CreateIndexRequest")
5523 }
5524
5525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
5526 where
5527 V: serde::de::MapAccess<'de>,
5528 {
5529 let mut index__ = None;
5530 let mut index_table__ = None;
5531 let mut fragment_graph__ = None;
5532 let mut if_not_exists__ = None;
5533 while let Some(k) = map_.next_key()? {
5534 match k {
5535 GeneratedField::Index => {
5536 if index__.is_some() {
5537 return Err(serde::de::Error::duplicate_field("index"));
5538 }
5539 index__ = map_.next_value()?;
5540 }
5541 GeneratedField::IndexTable => {
5542 if index_table__.is_some() {
5543 return Err(serde::de::Error::duplicate_field("indexTable"));
5544 }
5545 index_table__ = map_.next_value()?;
5546 }
5547 GeneratedField::FragmentGraph => {
5548 if fragment_graph__.is_some() {
5549 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5550 }
5551 fragment_graph__ = map_.next_value()?;
5552 }
5553 GeneratedField::IfNotExists => {
5554 if if_not_exists__.is_some() {
5555 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5556 }
5557 if_not_exists__ = Some(map_.next_value()?);
5558 }
5559 }
5560 }
5561 Ok(CreateIndexRequest {
5562 index: index__,
5563 index_table: index_table__,
5564 fragment_graph: fragment_graph__,
5565 if_not_exists: if_not_exists__.unwrap_or_default(),
5566 })
5567 }
5568 }
5569 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
5570 }
5571}
5572impl serde::Serialize for CreateIndexResponse {
5573 #[allow(deprecated)]
5574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5575 where
5576 S: serde::Serializer,
5577 {
5578 use serde::ser::SerializeStruct;
5579 let mut len = 0;
5580 if self.status.is_some() {
5581 len += 1;
5582 }
5583 if self.version.is_some() {
5584 len += 1;
5585 }
5586 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
5587 if let Some(v) = self.status.as_ref() {
5588 struct_ser.serialize_field("status", v)?;
5589 }
5590 if let Some(v) = self.version.as_ref() {
5591 struct_ser.serialize_field("version", v)?;
5592 }
5593 struct_ser.end()
5594 }
5595}
5596impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
5597 #[allow(deprecated)]
5598 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5599 where
5600 D: serde::Deserializer<'de>,
5601 {
5602 const FIELDS: &[&str] = &[
5603 "status",
5604 "version",
5605 ];
5606
5607 #[allow(clippy::enum_variant_names)]
5608 enum GeneratedField {
5609 Status,
5610 Version,
5611 }
5612 impl<'de> serde::Deserialize<'de> for GeneratedField {
5613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5614 where
5615 D: serde::Deserializer<'de>,
5616 {
5617 struct GeneratedVisitor;
5618
5619 impl serde::de::Visitor<'_> for GeneratedVisitor {
5620 type Value = GeneratedField;
5621
5622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5623 write!(formatter, "expected one of: {:?}", &FIELDS)
5624 }
5625
5626 #[allow(unused_variables)]
5627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5628 where
5629 E: serde::de::Error,
5630 {
5631 match value {
5632 "status" => Ok(GeneratedField::Status),
5633 "version" => Ok(GeneratedField::Version),
5634 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5635 }
5636 }
5637 }
5638 deserializer.deserialize_identifier(GeneratedVisitor)
5639 }
5640 }
5641 struct GeneratedVisitor;
5642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5643 type Value = CreateIndexResponse;
5644
5645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5646 formatter.write_str("struct ddl_service.CreateIndexResponse")
5647 }
5648
5649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
5650 where
5651 V: serde::de::MapAccess<'de>,
5652 {
5653 let mut status__ = None;
5654 let mut version__ = None;
5655 while let Some(k) = map_.next_key()? {
5656 match k {
5657 GeneratedField::Status => {
5658 if status__.is_some() {
5659 return Err(serde::de::Error::duplicate_field("status"));
5660 }
5661 status__ = map_.next_value()?;
5662 }
5663 GeneratedField::Version => {
5664 if version__.is_some() {
5665 return Err(serde::de::Error::duplicate_field("version"));
5666 }
5667 version__ = map_.next_value()?;
5668 }
5669 }
5670 }
5671 Ok(CreateIndexResponse {
5672 status: status__,
5673 version: version__,
5674 })
5675 }
5676 }
5677 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
5678 }
5679}
5680impl serde::Serialize for CreateMaterializedViewRequest {
5681 #[allow(deprecated)]
5682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5683 where
5684 S: serde::Serializer,
5685 {
5686 use serde::ser::SerializeStruct;
5687 let mut len = 0;
5688 if self.materialized_view.is_some() {
5689 len += 1;
5690 }
5691 if self.fragment_graph.is_some() {
5692 len += 1;
5693 }
5694 if self.resource_type.is_some() {
5695 len += 1;
5696 }
5697 if !self.dependencies.is_empty() {
5698 len += 1;
5699 }
5700 if self.if_not_exists {
5701 len += 1;
5702 }
5703 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
5704 if let Some(v) = self.materialized_view.as_ref() {
5705 struct_ser.serialize_field("materializedView", v)?;
5706 }
5707 if let Some(v) = self.fragment_graph.as_ref() {
5708 struct_ser.serialize_field("fragmentGraph", v)?;
5709 }
5710 if let Some(v) = self.resource_type.as_ref() {
5711 struct_ser.serialize_field("resourceType", v)?;
5712 }
5713 if !self.dependencies.is_empty() {
5714 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5715 }
5716 if self.if_not_exists {
5717 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5718 }
5719 struct_ser.end()
5720 }
5721}
5722impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
5723 #[allow(deprecated)]
5724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5725 where
5726 D: serde::Deserializer<'de>,
5727 {
5728 const FIELDS: &[&str] = &[
5729 "materialized_view",
5730 "materializedView",
5731 "fragment_graph",
5732 "fragmentGraph",
5733 "resource_type",
5734 "resourceType",
5735 "dependencies",
5736 "if_not_exists",
5737 "ifNotExists",
5738 ];
5739
5740 #[allow(clippy::enum_variant_names)]
5741 enum GeneratedField {
5742 MaterializedView,
5743 FragmentGraph,
5744 ResourceType,
5745 Dependencies,
5746 IfNotExists,
5747 }
5748 impl<'de> serde::Deserialize<'de> for GeneratedField {
5749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5750 where
5751 D: serde::Deserializer<'de>,
5752 {
5753 struct GeneratedVisitor;
5754
5755 impl serde::de::Visitor<'_> for GeneratedVisitor {
5756 type Value = GeneratedField;
5757
5758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5759 write!(formatter, "expected one of: {:?}", &FIELDS)
5760 }
5761
5762 #[allow(unused_variables)]
5763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5764 where
5765 E: serde::de::Error,
5766 {
5767 match value {
5768 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5769 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5770 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
5771 "dependencies" => Ok(GeneratedField::Dependencies),
5772 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5773 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5774 }
5775 }
5776 }
5777 deserializer.deserialize_identifier(GeneratedVisitor)
5778 }
5779 }
5780 struct GeneratedVisitor;
5781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5782 type Value = CreateMaterializedViewRequest;
5783
5784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5785 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
5786 }
5787
5788 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
5789 where
5790 V: serde::de::MapAccess<'de>,
5791 {
5792 let mut materialized_view__ = None;
5793 let mut fragment_graph__ = None;
5794 let mut resource_type__ = None;
5795 let mut dependencies__ = None;
5796 let mut if_not_exists__ = None;
5797 while let Some(k) = map_.next_key()? {
5798 match k {
5799 GeneratedField::MaterializedView => {
5800 if materialized_view__.is_some() {
5801 return Err(serde::de::Error::duplicate_field("materializedView"));
5802 }
5803 materialized_view__ = map_.next_value()?;
5804 }
5805 GeneratedField::FragmentGraph => {
5806 if fragment_graph__.is_some() {
5807 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5808 }
5809 fragment_graph__ = map_.next_value()?;
5810 }
5811 GeneratedField::ResourceType => {
5812 if resource_type__.is_some() {
5813 return Err(serde::de::Error::duplicate_field("resourceType"));
5814 }
5815 resource_type__ = map_.next_value()?;
5816 }
5817 GeneratedField::Dependencies => {
5818 if dependencies__.is_some() {
5819 return Err(serde::de::Error::duplicate_field("dependencies"));
5820 }
5821 dependencies__ =
5822 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5823 .into_iter().map(|x| x.0).collect())
5824 ;
5825 }
5826 GeneratedField::IfNotExists => {
5827 if if_not_exists__.is_some() {
5828 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5829 }
5830 if_not_exists__ = Some(map_.next_value()?);
5831 }
5832 }
5833 }
5834 Ok(CreateMaterializedViewRequest {
5835 materialized_view: materialized_view__,
5836 fragment_graph: fragment_graph__,
5837 resource_type: resource_type__,
5838 dependencies: dependencies__.unwrap_or_default(),
5839 if_not_exists: if_not_exists__.unwrap_or_default(),
5840 })
5841 }
5842 }
5843 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
5844 }
5845}
5846impl serde::Serialize for CreateMaterializedViewResponse {
5847 #[allow(deprecated)]
5848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5849 where
5850 S: serde::Serializer,
5851 {
5852 use serde::ser::SerializeStruct;
5853 let mut len = 0;
5854 if self.status.is_some() {
5855 len += 1;
5856 }
5857 if self.version.is_some() {
5858 len += 1;
5859 }
5860 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
5861 if let Some(v) = self.status.as_ref() {
5862 struct_ser.serialize_field("status", v)?;
5863 }
5864 if let Some(v) = self.version.as_ref() {
5865 struct_ser.serialize_field("version", v)?;
5866 }
5867 struct_ser.end()
5868 }
5869}
5870impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
5871 #[allow(deprecated)]
5872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5873 where
5874 D: serde::Deserializer<'de>,
5875 {
5876 const FIELDS: &[&str] = &[
5877 "status",
5878 "version",
5879 ];
5880
5881 #[allow(clippy::enum_variant_names)]
5882 enum GeneratedField {
5883 Status,
5884 Version,
5885 }
5886 impl<'de> serde::Deserialize<'de> for GeneratedField {
5887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5888 where
5889 D: serde::Deserializer<'de>,
5890 {
5891 struct GeneratedVisitor;
5892
5893 impl serde::de::Visitor<'_> for GeneratedVisitor {
5894 type Value = GeneratedField;
5895
5896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5897 write!(formatter, "expected one of: {:?}", &FIELDS)
5898 }
5899
5900 #[allow(unused_variables)]
5901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5902 where
5903 E: serde::de::Error,
5904 {
5905 match value {
5906 "status" => Ok(GeneratedField::Status),
5907 "version" => Ok(GeneratedField::Version),
5908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5909 }
5910 }
5911 }
5912 deserializer.deserialize_identifier(GeneratedVisitor)
5913 }
5914 }
5915 struct GeneratedVisitor;
5916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5917 type Value = CreateMaterializedViewResponse;
5918
5919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5920 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
5921 }
5922
5923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
5924 where
5925 V: serde::de::MapAccess<'de>,
5926 {
5927 let mut status__ = None;
5928 let mut version__ = None;
5929 while let Some(k) = map_.next_key()? {
5930 match k {
5931 GeneratedField::Status => {
5932 if status__.is_some() {
5933 return Err(serde::de::Error::duplicate_field("status"));
5934 }
5935 status__ = map_.next_value()?;
5936 }
5937 GeneratedField::Version => {
5938 if version__.is_some() {
5939 return Err(serde::de::Error::duplicate_field("version"));
5940 }
5941 version__ = map_.next_value()?;
5942 }
5943 }
5944 }
5945 Ok(CreateMaterializedViewResponse {
5946 status: status__,
5947 version: version__,
5948 })
5949 }
5950 }
5951 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
5952 }
5953}
5954impl serde::Serialize for CreateSchemaRequest {
5955 #[allow(deprecated)]
5956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5957 where
5958 S: serde::Serializer,
5959 {
5960 use serde::ser::SerializeStruct;
5961 let mut len = 0;
5962 if self.schema.is_some() {
5963 len += 1;
5964 }
5965 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
5966 if let Some(v) = self.schema.as_ref() {
5967 struct_ser.serialize_field("schema", v)?;
5968 }
5969 struct_ser.end()
5970 }
5971}
5972impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
5973 #[allow(deprecated)]
5974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5975 where
5976 D: serde::Deserializer<'de>,
5977 {
5978 const FIELDS: &[&str] = &[
5979 "schema",
5980 ];
5981
5982 #[allow(clippy::enum_variant_names)]
5983 enum GeneratedField {
5984 Schema,
5985 }
5986 impl<'de> serde::Deserialize<'de> for GeneratedField {
5987 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5988 where
5989 D: serde::Deserializer<'de>,
5990 {
5991 struct GeneratedVisitor;
5992
5993 impl serde::de::Visitor<'_> for GeneratedVisitor {
5994 type Value = GeneratedField;
5995
5996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5997 write!(formatter, "expected one of: {:?}", &FIELDS)
5998 }
5999
6000 #[allow(unused_variables)]
6001 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6002 where
6003 E: serde::de::Error,
6004 {
6005 match value {
6006 "schema" => Ok(GeneratedField::Schema),
6007 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6008 }
6009 }
6010 }
6011 deserializer.deserialize_identifier(GeneratedVisitor)
6012 }
6013 }
6014 struct GeneratedVisitor;
6015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6016 type Value = CreateSchemaRequest;
6017
6018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6019 formatter.write_str("struct ddl_service.CreateSchemaRequest")
6020 }
6021
6022 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
6023 where
6024 V: serde::de::MapAccess<'de>,
6025 {
6026 let mut schema__ = None;
6027 while let Some(k) = map_.next_key()? {
6028 match k {
6029 GeneratedField::Schema => {
6030 if schema__.is_some() {
6031 return Err(serde::de::Error::duplicate_field("schema"));
6032 }
6033 schema__ = map_.next_value()?;
6034 }
6035 }
6036 }
6037 Ok(CreateSchemaRequest {
6038 schema: schema__,
6039 })
6040 }
6041 }
6042 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
6043 }
6044}
6045impl serde::Serialize for CreateSchemaResponse {
6046 #[allow(deprecated)]
6047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6048 where
6049 S: serde::Serializer,
6050 {
6051 use serde::ser::SerializeStruct;
6052 let mut len = 0;
6053 if self.status.is_some() {
6054 len += 1;
6055 }
6056 if self.version.is_some() {
6057 len += 1;
6058 }
6059 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
6060 if let Some(v) = self.status.as_ref() {
6061 struct_ser.serialize_field("status", v)?;
6062 }
6063 if let Some(v) = self.version.as_ref() {
6064 struct_ser.serialize_field("version", v)?;
6065 }
6066 struct_ser.end()
6067 }
6068}
6069impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
6070 #[allow(deprecated)]
6071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6072 where
6073 D: serde::Deserializer<'de>,
6074 {
6075 const FIELDS: &[&str] = &[
6076 "status",
6077 "version",
6078 ];
6079
6080 #[allow(clippy::enum_variant_names)]
6081 enum GeneratedField {
6082 Status,
6083 Version,
6084 }
6085 impl<'de> serde::Deserialize<'de> for GeneratedField {
6086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6087 where
6088 D: serde::Deserializer<'de>,
6089 {
6090 struct GeneratedVisitor;
6091
6092 impl serde::de::Visitor<'_> for GeneratedVisitor {
6093 type Value = GeneratedField;
6094
6095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6096 write!(formatter, "expected one of: {:?}", &FIELDS)
6097 }
6098
6099 #[allow(unused_variables)]
6100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6101 where
6102 E: serde::de::Error,
6103 {
6104 match value {
6105 "status" => Ok(GeneratedField::Status),
6106 "version" => Ok(GeneratedField::Version),
6107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6108 }
6109 }
6110 }
6111 deserializer.deserialize_identifier(GeneratedVisitor)
6112 }
6113 }
6114 struct GeneratedVisitor;
6115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6116 type Value = CreateSchemaResponse;
6117
6118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6119 formatter.write_str("struct ddl_service.CreateSchemaResponse")
6120 }
6121
6122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
6123 where
6124 V: serde::de::MapAccess<'de>,
6125 {
6126 let mut status__ = None;
6127 let mut version__ = None;
6128 while let Some(k) = map_.next_key()? {
6129 match k {
6130 GeneratedField::Status => {
6131 if status__.is_some() {
6132 return Err(serde::de::Error::duplicate_field("status"));
6133 }
6134 status__ = map_.next_value()?;
6135 }
6136 GeneratedField::Version => {
6137 if version__.is_some() {
6138 return Err(serde::de::Error::duplicate_field("version"));
6139 }
6140 version__ = map_.next_value()?;
6141 }
6142 }
6143 }
6144 Ok(CreateSchemaResponse {
6145 status: status__,
6146 version: version__,
6147 })
6148 }
6149 }
6150 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
6151 }
6152}
6153impl serde::Serialize for CreateSecretRequest {
6154 #[allow(deprecated)]
6155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6156 where
6157 S: serde::Serializer,
6158 {
6159 use serde::ser::SerializeStruct;
6160 let mut len = 0;
6161 if !self.name.is_empty() {
6162 len += 1;
6163 }
6164 if !self.value.is_empty() {
6165 len += 1;
6166 }
6167 if self.database_id != 0 {
6168 len += 1;
6169 }
6170 if self.schema_id != 0 {
6171 len += 1;
6172 }
6173 if self.owner_id != 0 {
6174 len += 1;
6175 }
6176 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
6177 if !self.name.is_empty() {
6178 struct_ser.serialize_field("name", &self.name)?;
6179 }
6180 if !self.value.is_empty() {
6181 #[allow(clippy::needless_borrow)]
6182 #[allow(clippy::needless_borrows_for_generic_args)]
6183 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
6184 }
6185 if self.database_id != 0 {
6186 struct_ser.serialize_field("databaseId", &self.database_id)?;
6187 }
6188 if self.schema_id != 0 {
6189 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6190 }
6191 if self.owner_id != 0 {
6192 struct_ser.serialize_field("ownerId", &self.owner_id)?;
6193 }
6194 struct_ser.end()
6195 }
6196}
6197impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
6198 #[allow(deprecated)]
6199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6200 where
6201 D: serde::Deserializer<'de>,
6202 {
6203 const FIELDS: &[&str] = &[
6204 "name",
6205 "value",
6206 "database_id",
6207 "databaseId",
6208 "schema_id",
6209 "schemaId",
6210 "owner_id",
6211 "ownerId",
6212 ];
6213
6214 #[allow(clippy::enum_variant_names)]
6215 enum GeneratedField {
6216 Name,
6217 Value,
6218 DatabaseId,
6219 SchemaId,
6220 OwnerId,
6221 }
6222 impl<'de> serde::Deserialize<'de> for GeneratedField {
6223 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6224 where
6225 D: serde::Deserializer<'de>,
6226 {
6227 struct GeneratedVisitor;
6228
6229 impl serde::de::Visitor<'_> for GeneratedVisitor {
6230 type Value = GeneratedField;
6231
6232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6233 write!(formatter, "expected one of: {:?}", &FIELDS)
6234 }
6235
6236 #[allow(unused_variables)]
6237 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6238 where
6239 E: serde::de::Error,
6240 {
6241 match value {
6242 "name" => Ok(GeneratedField::Name),
6243 "value" => Ok(GeneratedField::Value),
6244 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6245 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6246 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
6247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6248 }
6249 }
6250 }
6251 deserializer.deserialize_identifier(GeneratedVisitor)
6252 }
6253 }
6254 struct GeneratedVisitor;
6255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6256 type Value = CreateSecretRequest;
6257
6258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6259 formatter.write_str("struct ddl_service.CreateSecretRequest")
6260 }
6261
6262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
6263 where
6264 V: serde::de::MapAccess<'de>,
6265 {
6266 let mut name__ = None;
6267 let mut value__ = None;
6268 let mut database_id__ = None;
6269 let mut schema_id__ = None;
6270 let mut owner_id__ = None;
6271 while let Some(k) = map_.next_key()? {
6272 match k {
6273 GeneratedField::Name => {
6274 if name__.is_some() {
6275 return Err(serde::de::Error::duplicate_field("name"));
6276 }
6277 name__ = Some(map_.next_value()?);
6278 }
6279 GeneratedField::Value => {
6280 if value__.is_some() {
6281 return Err(serde::de::Error::duplicate_field("value"));
6282 }
6283 value__ =
6284 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
6285 ;
6286 }
6287 GeneratedField::DatabaseId => {
6288 if database_id__.is_some() {
6289 return Err(serde::de::Error::duplicate_field("databaseId"));
6290 }
6291 database_id__ =
6292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6293 ;
6294 }
6295 GeneratedField::SchemaId => {
6296 if schema_id__.is_some() {
6297 return Err(serde::de::Error::duplicate_field("schemaId"));
6298 }
6299 schema_id__ =
6300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6301 ;
6302 }
6303 GeneratedField::OwnerId => {
6304 if owner_id__.is_some() {
6305 return Err(serde::de::Error::duplicate_field("ownerId"));
6306 }
6307 owner_id__ =
6308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6309 ;
6310 }
6311 }
6312 }
6313 Ok(CreateSecretRequest {
6314 name: name__.unwrap_or_default(),
6315 value: value__.unwrap_or_default(),
6316 database_id: database_id__.unwrap_or_default(),
6317 schema_id: schema_id__.unwrap_or_default(),
6318 owner_id: owner_id__.unwrap_or_default(),
6319 })
6320 }
6321 }
6322 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
6323 }
6324}
6325impl serde::Serialize for CreateSecretResponse {
6326 #[allow(deprecated)]
6327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6328 where
6329 S: serde::Serializer,
6330 {
6331 use serde::ser::SerializeStruct;
6332 let mut len = 0;
6333 if self.version.is_some() {
6334 len += 1;
6335 }
6336 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
6337 if let Some(v) = self.version.as_ref() {
6338 struct_ser.serialize_field("version", v)?;
6339 }
6340 struct_ser.end()
6341 }
6342}
6343impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
6344 #[allow(deprecated)]
6345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6346 where
6347 D: serde::Deserializer<'de>,
6348 {
6349 const FIELDS: &[&str] = &[
6350 "version",
6351 ];
6352
6353 #[allow(clippy::enum_variant_names)]
6354 enum GeneratedField {
6355 Version,
6356 }
6357 impl<'de> serde::Deserialize<'de> for GeneratedField {
6358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6359 where
6360 D: serde::Deserializer<'de>,
6361 {
6362 struct GeneratedVisitor;
6363
6364 impl serde::de::Visitor<'_> for GeneratedVisitor {
6365 type Value = GeneratedField;
6366
6367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6368 write!(formatter, "expected one of: {:?}", &FIELDS)
6369 }
6370
6371 #[allow(unused_variables)]
6372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6373 where
6374 E: serde::de::Error,
6375 {
6376 match value {
6377 "version" => Ok(GeneratedField::Version),
6378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6379 }
6380 }
6381 }
6382 deserializer.deserialize_identifier(GeneratedVisitor)
6383 }
6384 }
6385 struct GeneratedVisitor;
6386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6387 type Value = CreateSecretResponse;
6388
6389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6390 formatter.write_str("struct ddl_service.CreateSecretResponse")
6391 }
6392
6393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
6394 where
6395 V: serde::de::MapAccess<'de>,
6396 {
6397 let mut version__ = None;
6398 while let Some(k) = map_.next_key()? {
6399 match k {
6400 GeneratedField::Version => {
6401 if version__.is_some() {
6402 return Err(serde::de::Error::duplicate_field("version"));
6403 }
6404 version__ = map_.next_value()?;
6405 }
6406 }
6407 }
6408 Ok(CreateSecretResponse {
6409 version: version__,
6410 })
6411 }
6412 }
6413 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
6414 }
6415}
6416impl serde::Serialize for CreateSinkRequest {
6417 #[allow(deprecated)]
6418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6419 where
6420 S: serde::Serializer,
6421 {
6422 use serde::ser::SerializeStruct;
6423 let mut len = 0;
6424 if self.sink.is_some() {
6425 len += 1;
6426 }
6427 if self.fragment_graph.is_some() {
6428 len += 1;
6429 }
6430 if !self.dependencies.is_empty() {
6431 len += 1;
6432 }
6433 if self.if_not_exists {
6434 len += 1;
6435 }
6436 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
6437 if let Some(v) = self.sink.as_ref() {
6438 struct_ser.serialize_field("sink", v)?;
6439 }
6440 if let Some(v) = self.fragment_graph.as_ref() {
6441 struct_ser.serialize_field("fragmentGraph", v)?;
6442 }
6443 if !self.dependencies.is_empty() {
6444 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6445 }
6446 if self.if_not_exists {
6447 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6448 }
6449 struct_ser.end()
6450 }
6451}
6452impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6453 #[allow(deprecated)]
6454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6455 where
6456 D: serde::Deserializer<'de>,
6457 {
6458 const FIELDS: &[&str] = &[
6459 "sink",
6460 "fragment_graph",
6461 "fragmentGraph",
6462 "dependencies",
6463 "if_not_exists",
6464 "ifNotExists",
6465 ];
6466
6467 #[allow(clippy::enum_variant_names)]
6468 enum GeneratedField {
6469 Sink,
6470 FragmentGraph,
6471 Dependencies,
6472 IfNotExists,
6473 }
6474 impl<'de> serde::Deserialize<'de> for GeneratedField {
6475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6476 where
6477 D: serde::Deserializer<'de>,
6478 {
6479 struct GeneratedVisitor;
6480
6481 impl serde::de::Visitor<'_> for GeneratedVisitor {
6482 type Value = GeneratedField;
6483
6484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6485 write!(formatter, "expected one of: {:?}", &FIELDS)
6486 }
6487
6488 #[allow(unused_variables)]
6489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6490 where
6491 E: serde::de::Error,
6492 {
6493 match value {
6494 "sink" => Ok(GeneratedField::Sink),
6495 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6496 "dependencies" => Ok(GeneratedField::Dependencies),
6497 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6499 }
6500 }
6501 }
6502 deserializer.deserialize_identifier(GeneratedVisitor)
6503 }
6504 }
6505 struct GeneratedVisitor;
6506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6507 type Value = CreateSinkRequest;
6508
6509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6510 formatter.write_str("struct ddl_service.CreateSinkRequest")
6511 }
6512
6513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6514 where
6515 V: serde::de::MapAccess<'de>,
6516 {
6517 let mut sink__ = None;
6518 let mut fragment_graph__ = None;
6519 let mut dependencies__ = None;
6520 let mut if_not_exists__ = None;
6521 while let Some(k) = map_.next_key()? {
6522 match k {
6523 GeneratedField::Sink => {
6524 if sink__.is_some() {
6525 return Err(serde::de::Error::duplicate_field("sink"));
6526 }
6527 sink__ = map_.next_value()?;
6528 }
6529 GeneratedField::FragmentGraph => {
6530 if fragment_graph__.is_some() {
6531 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6532 }
6533 fragment_graph__ = map_.next_value()?;
6534 }
6535 GeneratedField::Dependencies => {
6536 if dependencies__.is_some() {
6537 return Err(serde::de::Error::duplicate_field("dependencies"));
6538 }
6539 dependencies__ =
6540 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6541 .into_iter().map(|x| x.0).collect())
6542 ;
6543 }
6544 GeneratedField::IfNotExists => {
6545 if if_not_exists__.is_some() {
6546 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6547 }
6548 if_not_exists__ = Some(map_.next_value()?);
6549 }
6550 }
6551 }
6552 Ok(CreateSinkRequest {
6553 sink: sink__,
6554 fragment_graph: fragment_graph__,
6555 dependencies: dependencies__.unwrap_or_default(),
6556 if_not_exists: if_not_exists__.unwrap_or_default(),
6557 })
6558 }
6559 }
6560 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6561 }
6562}
6563impl serde::Serialize for CreateSinkResponse {
6564 #[allow(deprecated)]
6565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6566 where
6567 S: serde::Serializer,
6568 {
6569 use serde::ser::SerializeStruct;
6570 let mut len = 0;
6571 if self.status.is_some() {
6572 len += 1;
6573 }
6574 if self.version.is_some() {
6575 len += 1;
6576 }
6577 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6578 if let Some(v) = self.status.as_ref() {
6579 struct_ser.serialize_field("status", v)?;
6580 }
6581 if let Some(v) = self.version.as_ref() {
6582 struct_ser.serialize_field("version", v)?;
6583 }
6584 struct_ser.end()
6585 }
6586}
6587impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6588 #[allow(deprecated)]
6589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6590 where
6591 D: serde::Deserializer<'de>,
6592 {
6593 const FIELDS: &[&str] = &[
6594 "status",
6595 "version",
6596 ];
6597
6598 #[allow(clippy::enum_variant_names)]
6599 enum GeneratedField {
6600 Status,
6601 Version,
6602 }
6603 impl<'de> serde::Deserialize<'de> for GeneratedField {
6604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6605 where
6606 D: serde::Deserializer<'de>,
6607 {
6608 struct GeneratedVisitor;
6609
6610 impl serde::de::Visitor<'_> for GeneratedVisitor {
6611 type Value = GeneratedField;
6612
6613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6614 write!(formatter, "expected one of: {:?}", &FIELDS)
6615 }
6616
6617 #[allow(unused_variables)]
6618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6619 where
6620 E: serde::de::Error,
6621 {
6622 match value {
6623 "status" => Ok(GeneratedField::Status),
6624 "version" => Ok(GeneratedField::Version),
6625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6626 }
6627 }
6628 }
6629 deserializer.deserialize_identifier(GeneratedVisitor)
6630 }
6631 }
6632 struct GeneratedVisitor;
6633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6634 type Value = CreateSinkResponse;
6635
6636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6637 formatter.write_str("struct ddl_service.CreateSinkResponse")
6638 }
6639
6640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6641 where
6642 V: serde::de::MapAccess<'de>,
6643 {
6644 let mut status__ = None;
6645 let mut version__ = None;
6646 while let Some(k) = map_.next_key()? {
6647 match k {
6648 GeneratedField::Status => {
6649 if status__.is_some() {
6650 return Err(serde::de::Error::duplicate_field("status"));
6651 }
6652 status__ = map_.next_value()?;
6653 }
6654 GeneratedField::Version => {
6655 if version__.is_some() {
6656 return Err(serde::de::Error::duplicate_field("version"));
6657 }
6658 version__ = map_.next_value()?;
6659 }
6660 }
6661 }
6662 Ok(CreateSinkResponse {
6663 status: status__,
6664 version: version__,
6665 })
6666 }
6667 }
6668 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
6669 }
6670}
6671impl serde::Serialize for CreateSourceRequest {
6672 #[allow(deprecated)]
6673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6674 where
6675 S: serde::Serializer,
6676 {
6677 use serde::ser::SerializeStruct;
6678 let mut len = 0;
6679 if self.source.is_some() {
6680 len += 1;
6681 }
6682 if self.fragment_graph.is_some() {
6683 len += 1;
6684 }
6685 if self.if_not_exists {
6686 len += 1;
6687 }
6688 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
6689 if let Some(v) = self.source.as_ref() {
6690 struct_ser.serialize_field("source", v)?;
6691 }
6692 if let Some(v) = self.fragment_graph.as_ref() {
6693 struct_ser.serialize_field("fragmentGraph", v)?;
6694 }
6695 if self.if_not_exists {
6696 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6697 }
6698 struct_ser.end()
6699 }
6700}
6701impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
6702 #[allow(deprecated)]
6703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6704 where
6705 D: serde::Deserializer<'de>,
6706 {
6707 const FIELDS: &[&str] = &[
6708 "source",
6709 "fragment_graph",
6710 "fragmentGraph",
6711 "if_not_exists",
6712 "ifNotExists",
6713 ];
6714
6715 #[allow(clippy::enum_variant_names)]
6716 enum GeneratedField {
6717 Source,
6718 FragmentGraph,
6719 IfNotExists,
6720 }
6721 impl<'de> serde::Deserialize<'de> for GeneratedField {
6722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6723 where
6724 D: serde::Deserializer<'de>,
6725 {
6726 struct GeneratedVisitor;
6727
6728 impl serde::de::Visitor<'_> for GeneratedVisitor {
6729 type Value = GeneratedField;
6730
6731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6732 write!(formatter, "expected one of: {:?}", &FIELDS)
6733 }
6734
6735 #[allow(unused_variables)]
6736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6737 where
6738 E: serde::de::Error,
6739 {
6740 match value {
6741 "source" => Ok(GeneratedField::Source),
6742 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6743 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6744 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6745 }
6746 }
6747 }
6748 deserializer.deserialize_identifier(GeneratedVisitor)
6749 }
6750 }
6751 struct GeneratedVisitor;
6752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6753 type Value = CreateSourceRequest;
6754
6755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6756 formatter.write_str("struct ddl_service.CreateSourceRequest")
6757 }
6758
6759 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
6760 where
6761 V: serde::de::MapAccess<'de>,
6762 {
6763 let mut source__ = None;
6764 let mut fragment_graph__ = None;
6765 let mut if_not_exists__ = None;
6766 while let Some(k) = map_.next_key()? {
6767 match k {
6768 GeneratedField::Source => {
6769 if source__.is_some() {
6770 return Err(serde::de::Error::duplicate_field("source"));
6771 }
6772 source__ = map_.next_value()?;
6773 }
6774 GeneratedField::FragmentGraph => {
6775 if fragment_graph__.is_some() {
6776 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6777 }
6778 fragment_graph__ = map_.next_value()?;
6779 }
6780 GeneratedField::IfNotExists => {
6781 if if_not_exists__.is_some() {
6782 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6783 }
6784 if_not_exists__ = Some(map_.next_value()?);
6785 }
6786 }
6787 }
6788 Ok(CreateSourceRequest {
6789 source: source__,
6790 fragment_graph: fragment_graph__,
6791 if_not_exists: if_not_exists__.unwrap_or_default(),
6792 })
6793 }
6794 }
6795 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
6796 }
6797}
6798impl serde::Serialize for CreateSourceResponse {
6799 #[allow(deprecated)]
6800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6801 where
6802 S: serde::Serializer,
6803 {
6804 use serde::ser::SerializeStruct;
6805 let mut len = 0;
6806 if self.status.is_some() {
6807 len += 1;
6808 }
6809 if self.version.is_some() {
6810 len += 1;
6811 }
6812 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
6813 if let Some(v) = self.status.as_ref() {
6814 struct_ser.serialize_field("status", v)?;
6815 }
6816 if let Some(v) = self.version.as_ref() {
6817 struct_ser.serialize_field("version", v)?;
6818 }
6819 struct_ser.end()
6820 }
6821}
6822impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
6823 #[allow(deprecated)]
6824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6825 where
6826 D: serde::Deserializer<'de>,
6827 {
6828 const FIELDS: &[&str] = &[
6829 "status",
6830 "version",
6831 ];
6832
6833 #[allow(clippy::enum_variant_names)]
6834 enum GeneratedField {
6835 Status,
6836 Version,
6837 }
6838 impl<'de> serde::Deserialize<'de> for GeneratedField {
6839 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6840 where
6841 D: serde::Deserializer<'de>,
6842 {
6843 struct GeneratedVisitor;
6844
6845 impl serde::de::Visitor<'_> for GeneratedVisitor {
6846 type Value = GeneratedField;
6847
6848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6849 write!(formatter, "expected one of: {:?}", &FIELDS)
6850 }
6851
6852 #[allow(unused_variables)]
6853 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6854 where
6855 E: serde::de::Error,
6856 {
6857 match value {
6858 "status" => Ok(GeneratedField::Status),
6859 "version" => Ok(GeneratedField::Version),
6860 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6861 }
6862 }
6863 }
6864 deserializer.deserialize_identifier(GeneratedVisitor)
6865 }
6866 }
6867 struct GeneratedVisitor;
6868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6869 type Value = CreateSourceResponse;
6870
6871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6872 formatter.write_str("struct ddl_service.CreateSourceResponse")
6873 }
6874
6875 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
6876 where
6877 V: serde::de::MapAccess<'de>,
6878 {
6879 let mut status__ = None;
6880 let mut version__ = None;
6881 while let Some(k) = map_.next_key()? {
6882 match k {
6883 GeneratedField::Status => {
6884 if status__.is_some() {
6885 return Err(serde::de::Error::duplicate_field("status"));
6886 }
6887 status__ = map_.next_value()?;
6888 }
6889 GeneratedField::Version => {
6890 if version__.is_some() {
6891 return Err(serde::de::Error::duplicate_field("version"));
6892 }
6893 version__ = map_.next_value()?;
6894 }
6895 }
6896 }
6897 Ok(CreateSourceResponse {
6898 status: status__,
6899 version: version__,
6900 })
6901 }
6902 }
6903 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
6904 }
6905}
6906impl serde::Serialize for CreateSubscriptionRequest {
6907 #[allow(deprecated)]
6908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6909 where
6910 S: serde::Serializer,
6911 {
6912 use serde::ser::SerializeStruct;
6913 let mut len = 0;
6914 if self.subscription.is_some() {
6915 len += 1;
6916 }
6917 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
6918 if let Some(v) = self.subscription.as_ref() {
6919 struct_ser.serialize_field("subscription", v)?;
6920 }
6921 struct_ser.end()
6922 }
6923}
6924impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
6925 #[allow(deprecated)]
6926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6927 where
6928 D: serde::Deserializer<'de>,
6929 {
6930 const FIELDS: &[&str] = &[
6931 "subscription",
6932 ];
6933
6934 #[allow(clippy::enum_variant_names)]
6935 enum GeneratedField {
6936 Subscription,
6937 }
6938 impl<'de> serde::Deserialize<'de> for GeneratedField {
6939 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6940 where
6941 D: serde::Deserializer<'de>,
6942 {
6943 struct GeneratedVisitor;
6944
6945 impl serde::de::Visitor<'_> for GeneratedVisitor {
6946 type Value = GeneratedField;
6947
6948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6949 write!(formatter, "expected one of: {:?}", &FIELDS)
6950 }
6951
6952 #[allow(unused_variables)]
6953 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6954 where
6955 E: serde::de::Error,
6956 {
6957 match value {
6958 "subscription" => Ok(GeneratedField::Subscription),
6959 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6960 }
6961 }
6962 }
6963 deserializer.deserialize_identifier(GeneratedVisitor)
6964 }
6965 }
6966 struct GeneratedVisitor;
6967 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6968 type Value = CreateSubscriptionRequest;
6969
6970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6971 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
6972 }
6973
6974 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
6975 where
6976 V: serde::de::MapAccess<'de>,
6977 {
6978 let mut subscription__ = None;
6979 while let Some(k) = map_.next_key()? {
6980 match k {
6981 GeneratedField::Subscription => {
6982 if subscription__.is_some() {
6983 return Err(serde::de::Error::duplicate_field("subscription"));
6984 }
6985 subscription__ = map_.next_value()?;
6986 }
6987 }
6988 }
6989 Ok(CreateSubscriptionRequest {
6990 subscription: subscription__,
6991 })
6992 }
6993 }
6994 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
6995 }
6996}
6997impl serde::Serialize for CreateSubscriptionResponse {
6998 #[allow(deprecated)]
6999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7000 where
7001 S: serde::Serializer,
7002 {
7003 use serde::ser::SerializeStruct;
7004 let mut len = 0;
7005 if self.status.is_some() {
7006 len += 1;
7007 }
7008 if self.version.is_some() {
7009 len += 1;
7010 }
7011 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
7012 if let Some(v) = self.status.as_ref() {
7013 struct_ser.serialize_field("status", v)?;
7014 }
7015 if let Some(v) = self.version.as_ref() {
7016 struct_ser.serialize_field("version", v)?;
7017 }
7018 struct_ser.end()
7019 }
7020}
7021impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
7022 #[allow(deprecated)]
7023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7024 where
7025 D: serde::Deserializer<'de>,
7026 {
7027 const FIELDS: &[&str] = &[
7028 "status",
7029 "version",
7030 ];
7031
7032 #[allow(clippy::enum_variant_names)]
7033 enum GeneratedField {
7034 Status,
7035 Version,
7036 }
7037 impl<'de> serde::Deserialize<'de> for GeneratedField {
7038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7039 where
7040 D: serde::Deserializer<'de>,
7041 {
7042 struct GeneratedVisitor;
7043
7044 impl serde::de::Visitor<'_> for GeneratedVisitor {
7045 type Value = GeneratedField;
7046
7047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7048 write!(formatter, "expected one of: {:?}", &FIELDS)
7049 }
7050
7051 #[allow(unused_variables)]
7052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7053 where
7054 E: serde::de::Error,
7055 {
7056 match value {
7057 "status" => Ok(GeneratedField::Status),
7058 "version" => Ok(GeneratedField::Version),
7059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7060 }
7061 }
7062 }
7063 deserializer.deserialize_identifier(GeneratedVisitor)
7064 }
7065 }
7066 struct GeneratedVisitor;
7067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7068 type Value = CreateSubscriptionResponse;
7069
7070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7071 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
7072 }
7073
7074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
7075 where
7076 V: serde::de::MapAccess<'de>,
7077 {
7078 let mut status__ = None;
7079 let mut version__ = None;
7080 while let Some(k) = map_.next_key()? {
7081 match k {
7082 GeneratedField::Status => {
7083 if status__.is_some() {
7084 return Err(serde::de::Error::duplicate_field("status"));
7085 }
7086 status__ = map_.next_value()?;
7087 }
7088 GeneratedField::Version => {
7089 if version__.is_some() {
7090 return Err(serde::de::Error::duplicate_field("version"));
7091 }
7092 version__ = map_.next_value()?;
7093 }
7094 }
7095 }
7096 Ok(CreateSubscriptionResponse {
7097 status: status__,
7098 version: version__,
7099 })
7100 }
7101 }
7102 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
7103 }
7104}
7105impl serde::Serialize for CreateTableRequest {
7106 #[allow(deprecated)]
7107 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7108 where
7109 S: serde::Serializer,
7110 {
7111 use serde::ser::SerializeStruct;
7112 let mut len = 0;
7113 if self.source.is_some() {
7114 len += 1;
7115 }
7116 if self.materialized_view.is_some() {
7117 len += 1;
7118 }
7119 if self.fragment_graph.is_some() {
7120 len += 1;
7121 }
7122 if self.job_type != 0 {
7123 len += 1;
7124 }
7125 if self.if_not_exists {
7126 len += 1;
7127 }
7128 if !self.dependencies.is_empty() {
7129 len += 1;
7130 }
7131 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
7132 if let Some(v) = self.source.as_ref() {
7133 struct_ser.serialize_field("source", v)?;
7134 }
7135 if let Some(v) = self.materialized_view.as_ref() {
7136 struct_ser.serialize_field("materializedView", v)?;
7137 }
7138 if let Some(v) = self.fragment_graph.as_ref() {
7139 struct_ser.serialize_field("fragmentGraph", v)?;
7140 }
7141 if self.job_type != 0 {
7142 let v = TableJobType::try_from(self.job_type)
7143 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
7144 struct_ser.serialize_field("jobType", &v)?;
7145 }
7146 if self.if_not_exists {
7147 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7148 }
7149 if !self.dependencies.is_empty() {
7150 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7151 }
7152 struct_ser.end()
7153 }
7154}
7155impl<'de> serde::Deserialize<'de> for CreateTableRequest {
7156 #[allow(deprecated)]
7157 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7158 where
7159 D: serde::Deserializer<'de>,
7160 {
7161 const FIELDS: &[&str] = &[
7162 "source",
7163 "materialized_view",
7164 "materializedView",
7165 "fragment_graph",
7166 "fragmentGraph",
7167 "job_type",
7168 "jobType",
7169 "if_not_exists",
7170 "ifNotExists",
7171 "dependencies",
7172 ];
7173
7174 #[allow(clippy::enum_variant_names)]
7175 enum GeneratedField {
7176 Source,
7177 MaterializedView,
7178 FragmentGraph,
7179 JobType,
7180 IfNotExists,
7181 Dependencies,
7182 }
7183 impl<'de> serde::Deserialize<'de> for GeneratedField {
7184 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7185 where
7186 D: serde::Deserializer<'de>,
7187 {
7188 struct GeneratedVisitor;
7189
7190 impl serde::de::Visitor<'_> for GeneratedVisitor {
7191 type Value = GeneratedField;
7192
7193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7194 write!(formatter, "expected one of: {:?}", &FIELDS)
7195 }
7196
7197 #[allow(unused_variables)]
7198 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7199 where
7200 E: serde::de::Error,
7201 {
7202 match value {
7203 "source" => Ok(GeneratedField::Source),
7204 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
7205 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7206 "jobType" | "job_type" => Ok(GeneratedField::JobType),
7207 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7208 "dependencies" => Ok(GeneratedField::Dependencies),
7209 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7210 }
7211 }
7212 }
7213 deserializer.deserialize_identifier(GeneratedVisitor)
7214 }
7215 }
7216 struct GeneratedVisitor;
7217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7218 type Value = CreateTableRequest;
7219
7220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7221 formatter.write_str("struct ddl_service.CreateTableRequest")
7222 }
7223
7224 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
7225 where
7226 V: serde::de::MapAccess<'de>,
7227 {
7228 let mut source__ = None;
7229 let mut materialized_view__ = None;
7230 let mut fragment_graph__ = None;
7231 let mut job_type__ = None;
7232 let mut if_not_exists__ = None;
7233 let mut dependencies__ = None;
7234 while let Some(k) = map_.next_key()? {
7235 match k {
7236 GeneratedField::Source => {
7237 if source__.is_some() {
7238 return Err(serde::de::Error::duplicate_field("source"));
7239 }
7240 source__ = map_.next_value()?;
7241 }
7242 GeneratedField::MaterializedView => {
7243 if materialized_view__.is_some() {
7244 return Err(serde::de::Error::duplicate_field("materializedView"));
7245 }
7246 materialized_view__ = map_.next_value()?;
7247 }
7248 GeneratedField::FragmentGraph => {
7249 if fragment_graph__.is_some() {
7250 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7251 }
7252 fragment_graph__ = map_.next_value()?;
7253 }
7254 GeneratedField::JobType => {
7255 if job_type__.is_some() {
7256 return Err(serde::de::Error::duplicate_field("jobType"));
7257 }
7258 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
7259 }
7260 GeneratedField::IfNotExists => {
7261 if if_not_exists__.is_some() {
7262 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7263 }
7264 if_not_exists__ = Some(map_.next_value()?);
7265 }
7266 GeneratedField::Dependencies => {
7267 if dependencies__.is_some() {
7268 return Err(serde::de::Error::duplicate_field("dependencies"));
7269 }
7270 dependencies__ =
7271 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7272 .into_iter().map(|x| x.0).collect())
7273 ;
7274 }
7275 }
7276 }
7277 Ok(CreateTableRequest {
7278 source: source__,
7279 materialized_view: materialized_view__,
7280 fragment_graph: fragment_graph__,
7281 job_type: job_type__.unwrap_or_default(),
7282 if_not_exists: if_not_exists__.unwrap_or_default(),
7283 dependencies: dependencies__.unwrap_or_default(),
7284 })
7285 }
7286 }
7287 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
7288 }
7289}
7290impl serde::Serialize for CreateTableResponse {
7291 #[allow(deprecated)]
7292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7293 where
7294 S: serde::Serializer,
7295 {
7296 use serde::ser::SerializeStruct;
7297 let mut len = 0;
7298 if self.status.is_some() {
7299 len += 1;
7300 }
7301 if self.version.is_some() {
7302 len += 1;
7303 }
7304 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
7305 if let Some(v) = self.status.as_ref() {
7306 struct_ser.serialize_field("status", v)?;
7307 }
7308 if let Some(v) = self.version.as_ref() {
7309 struct_ser.serialize_field("version", v)?;
7310 }
7311 struct_ser.end()
7312 }
7313}
7314impl<'de> serde::Deserialize<'de> for CreateTableResponse {
7315 #[allow(deprecated)]
7316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7317 where
7318 D: serde::Deserializer<'de>,
7319 {
7320 const FIELDS: &[&str] = &[
7321 "status",
7322 "version",
7323 ];
7324
7325 #[allow(clippy::enum_variant_names)]
7326 enum GeneratedField {
7327 Status,
7328 Version,
7329 }
7330 impl<'de> serde::Deserialize<'de> for GeneratedField {
7331 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7332 where
7333 D: serde::Deserializer<'de>,
7334 {
7335 struct GeneratedVisitor;
7336
7337 impl serde::de::Visitor<'_> for GeneratedVisitor {
7338 type Value = GeneratedField;
7339
7340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7341 write!(formatter, "expected one of: {:?}", &FIELDS)
7342 }
7343
7344 #[allow(unused_variables)]
7345 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7346 where
7347 E: serde::de::Error,
7348 {
7349 match value {
7350 "status" => Ok(GeneratedField::Status),
7351 "version" => Ok(GeneratedField::Version),
7352 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7353 }
7354 }
7355 }
7356 deserializer.deserialize_identifier(GeneratedVisitor)
7357 }
7358 }
7359 struct GeneratedVisitor;
7360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7361 type Value = CreateTableResponse;
7362
7363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7364 formatter.write_str("struct ddl_service.CreateTableResponse")
7365 }
7366
7367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
7368 where
7369 V: serde::de::MapAccess<'de>,
7370 {
7371 let mut status__ = None;
7372 let mut version__ = None;
7373 while let Some(k) = map_.next_key()? {
7374 match k {
7375 GeneratedField::Status => {
7376 if status__.is_some() {
7377 return Err(serde::de::Error::duplicate_field("status"));
7378 }
7379 status__ = map_.next_value()?;
7380 }
7381 GeneratedField::Version => {
7382 if version__.is_some() {
7383 return Err(serde::de::Error::duplicate_field("version"));
7384 }
7385 version__ = map_.next_value()?;
7386 }
7387 }
7388 }
7389 Ok(CreateTableResponse {
7390 status: status__,
7391 version: version__,
7392 })
7393 }
7394 }
7395 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
7396 }
7397}
7398impl serde::Serialize for CreateViewRequest {
7399 #[allow(deprecated)]
7400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7401 where
7402 S: serde::Serializer,
7403 {
7404 use serde::ser::SerializeStruct;
7405 let mut len = 0;
7406 if self.view.is_some() {
7407 len += 1;
7408 }
7409 if !self.dependencies.is_empty() {
7410 len += 1;
7411 }
7412 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
7413 if let Some(v) = self.view.as_ref() {
7414 struct_ser.serialize_field("view", v)?;
7415 }
7416 if !self.dependencies.is_empty() {
7417 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7418 }
7419 struct_ser.end()
7420 }
7421}
7422impl<'de> serde::Deserialize<'de> for CreateViewRequest {
7423 #[allow(deprecated)]
7424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7425 where
7426 D: serde::Deserializer<'de>,
7427 {
7428 const FIELDS: &[&str] = &[
7429 "view",
7430 "dependencies",
7431 ];
7432
7433 #[allow(clippy::enum_variant_names)]
7434 enum GeneratedField {
7435 View,
7436 Dependencies,
7437 }
7438 impl<'de> serde::Deserialize<'de> for GeneratedField {
7439 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7440 where
7441 D: serde::Deserializer<'de>,
7442 {
7443 struct GeneratedVisitor;
7444
7445 impl serde::de::Visitor<'_> for GeneratedVisitor {
7446 type Value = GeneratedField;
7447
7448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7449 write!(formatter, "expected one of: {:?}", &FIELDS)
7450 }
7451
7452 #[allow(unused_variables)]
7453 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7454 where
7455 E: serde::de::Error,
7456 {
7457 match value {
7458 "view" => Ok(GeneratedField::View),
7459 "dependencies" => Ok(GeneratedField::Dependencies),
7460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7461 }
7462 }
7463 }
7464 deserializer.deserialize_identifier(GeneratedVisitor)
7465 }
7466 }
7467 struct GeneratedVisitor;
7468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7469 type Value = CreateViewRequest;
7470
7471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7472 formatter.write_str("struct ddl_service.CreateViewRequest")
7473 }
7474
7475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7476 where
7477 V: serde::de::MapAccess<'de>,
7478 {
7479 let mut view__ = None;
7480 let mut dependencies__ = None;
7481 while let Some(k) = map_.next_key()? {
7482 match k {
7483 GeneratedField::View => {
7484 if view__.is_some() {
7485 return Err(serde::de::Error::duplicate_field("view"));
7486 }
7487 view__ = map_.next_value()?;
7488 }
7489 GeneratedField::Dependencies => {
7490 if dependencies__.is_some() {
7491 return Err(serde::de::Error::duplicate_field("dependencies"));
7492 }
7493 dependencies__ =
7494 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7495 .into_iter().map(|x| x.0).collect())
7496 ;
7497 }
7498 }
7499 }
7500 Ok(CreateViewRequest {
7501 view: view__,
7502 dependencies: dependencies__.unwrap_or_default(),
7503 })
7504 }
7505 }
7506 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7507 }
7508}
7509impl serde::Serialize for CreateViewResponse {
7510 #[allow(deprecated)]
7511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7512 where
7513 S: serde::Serializer,
7514 {
7515 use serde::ser::SerializeStruct;
7516 let mut len = 0;
7517 if self.status.is_some() {
7518 len += 1;
7519 }
7520 if self.version.is_some() {
7521 len += 1;
7522 }
7523 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7524 if let Some(v) = self.status.as_ref() {
7525 struct_ser.serialize_field("status", v)?;
7526 }
7527 if let Some(v) = self.version.as_ref() {
7528 struct_ser.serialize_field("version", v)?;
7529 }
7530 struct_ser.end()
7531 }
7532}
7533impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7534 #[allow(deprecated)]
7535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7536 where
7537 D: serde::Deserializer<'de>,
7538 {
7539 const FIELDS: &[&str] = &[
7540 "status",
7541 "version",
7542 ];
7543
7544 #[allow(clippy::enum_variant_names)]
7545 enum GeneratedField {
7546 Status,
7547 Version,
7548 }
7549 impl<'de> serde::Deserialize<'de> for GeneratedField {
7550 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7551 where
7552 D: serde::Deserializer<'de>,
7553 {
7554 struct GeneratedVisitor;
7555
7556 impl serde::de::Visitor<'_> for GeneratedVisitor {
7557 type Value = GeneratedField;
7558
7559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7560 write!(formatter, "expected one of: {:?}", &FIELDS)
7561 }
7562
7563 #[allow(unused_variables)]
7564 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7565 where
7566 E: serde::de::Error,
7567 {
7568 match value {
7569 "status" => Ok(GeneratedField::Status),
7570 "version" => Ok(GeneratedField::Version),
7571 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7572 }
7573 }
7574 }
7575 deserializer.deserialize_identifier(GeneratedVisitor)
7576 }
7577 }
7578 struct GeneratedVisitor;
7579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7580 type Value = CreateViewResponse;
7581
7582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7583 formatter.write_str("struct ddl_service.CreateViewResponse")
7584 }
7585
7586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7587 where
7588 V: serde::de::MapAccess<'de>,
7589 {
7590 let mut status__ = None;
7591 let mut version__ = None;
7592 while let Some(k) = map_.next_key()? {
7593 match k {
7594 GeneratedField::Status => {
7595 if status__.is_some() {
7596 return Err(serde::de::Error::duplicate_field("status"));
7597 }
7598 status__ = map_.next_value()?;
7599 }
7600 GeneratedField::Version => {
7601 if version__.is_some() {
7602 return Err(serde::de::Error::duplicate_field("version"));
7603 }
7604 version__ = map_.next_value()?;
7605 }
7606 }
7607 }
7608 Ok(CreateViewResponse {
7609 status: status__,
7610 version: version__,
7611 })
7612 }
7613 }
7614 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7615 }
7616}
7617impl serde::Serialize for DdlProgress {
7618 #[allow(deprecated)]
7619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7620 where
7621 S: serde::Serializer,
7622 {
7623 use serde::ser::SerializeStruct;
7624 let mut len = 0;
7625 if self.id != 0 {
7626 len += 1;
7627 }
7628 if !self.statement.is_empty() {
7629 len += 1;
7630 }
7631 if !self.progress.is_empty() {
7632 len += 1;
7633 }
7634 if !self.create_type.is_empty() {
7635 len += 1;
7636 }
7637 if self.initialized_at_time_millis != 0 {
7638 len += 1;
7639 }
7640 if self.is_serverless_backfill {
7641 len += 1;
7642 }
7643 if self.backfill_type != 0 {
7644 len += 1;
7645 }
7646 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
7647 if self.id != 0 {
7648 #[allow(clippy::needless_borrow)]
7649 #[allow(clippy::needless_borrows_for_generic_args)]
7650 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7651 }
7652 if !self.statement.is_empty() {
7653 struct_ser.serialize_field("statement", &self.statement)?;
7654 }
7655 if !self.progress.is_empty() {
7656 struct_ser.serialize_field("progress", &self.progress)?;
7657 }
7658 if !self.create_type.is_empty() {
7659 struct_ser.serialize_field("createType", &self.create_type)?;
7660 }
7661 if self.initialized_at_time_millis != 0 {
7662 #[allow(clippy::needless_borrow)]
7663 #[allow(clippy::needless_borrows_for_generic_args)]
7664 struct_ser.serialize_field("initializedAtTimeMillis", ToString::to_string(&self.initialized_at_time_millis).as_str())?;
7665 }
7666 if self.is_serverless_backfill {
7667 struct_ser.serialize_field("isServerlessBackfill", &self.is_serverless_backfill)?;
7668 }
7669 if self.backfill_type != 0 {
7670 let v = BackfillType::try_from(self.backfill_type)
7671 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill_type)))?;
7672 struct_ser.serialize_field("backfillType", &v)?;
7673 }
7674 struct_ser.end()
7675 }
7676}
7677impl<'de> serde::Deserialize<'de> for DdlProgress {
7678 #[allow(deprecated)]
7679 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7680 where
7681 D: serde::Deserializer<'de>,
7682 {
7683 const FIELDS: &[&str] = &[
7684 "id",
7685 "statement",
7686 "progress",
7687 "create_type",
7688 "createType",
7689 "initialized_at_time_millis",
7690 "initializedAtTimeMillis",
7691 "is_serverless_backfill",
7692 "isServerlessBackfill",
7693 "backfill_type",
7694 "backfillType",
7695 ];
7696
7697 #[allow(clippy::enum_variant_names)]
7698 enum GeneratedField {
7699 Id,
7700 Statement,
7701 Progress,
7702 CreateType,
7703 InitializedAtTimeMillis,
7704 IsServerlessBackfill,
7705 BackfillType,
7706 }
7707 impl<'de> serde::Deserialize<'de> for GeneratedField {
7708 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7709 where
7710 D: serde::Deserializer<'de>,
7711 {
7712 struct GeneratedVisitor;
7713
7714 impl serde::de::Visitor<'_> for GeneratedVisitor {
7715 type Value = GeneratedField;
7716
7717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7718 write!(formatter, "expected one of: {:?}", &FIELDS)
7719 }
7720
7721 #[allow(unused_variables)]
7722 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7723 where
7724 E: serde::de::Error,
7725 {
7726 match value {
7727 "id" => Ok(GeneratedField::Id),
7728 "statement" => Ok(GeneratedField::Statement),
7729 "progress" => Ok(GeneratedField::Progress),
7730 "createType" | "create_type" => Ok(GeneratedField::CreateType),
7731 "initializedAtTimeMillis" | "initialized_at_time_millis" => Ok(GeneratedField::InitializedAtTimeMillis),
7732 "isServerlessBackfill" | "is_serverless_backfill" => Ok(GeneratedField::IsServerlessBackfill),
7733 "backfillType" | "backfill_type" => Ok(GeneratedField::BackfillType),
7734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7735 }
7736 }
7737 }
7738 deserializer.deserialize_identifier(GeneratedVisitor)
7739 }
7740 }
7741 struct GeneratedVisitor;
7742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7743 type Value = DdlProgress;
7744
7745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7746 formatter.write_str("struct ddl_service.DdlProgress")
7747 }
7748
7749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
7750 where
7751 V: serde::de::MapAccess<'de>,
7752 {
7753 let mut id__ = None;
7754 let mut statement__ = None;
7755 let mut progress__ = None;
7756 let mut create_type__ = None;
7757 let mut initialized_at_time_millis__ = None;
7758 let mut is_serverless_backfill__ = None;
7759 let mut backfill_type__ = None;
7760 while let Some(k) = map_.next_key()? {
7761 match k {
7762 GeneratedField::Id => {
7763 if id__.is_some() {
7764 return Err(serde::de::Error::duplicate_field("id"));
7765 }
7766 id__ =
7767 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7768 ;
7769 }
7770 GeneratedField::Statement => {
7771 if statement__.is_some() {
7772 return Err(serde::de::Error::duplicate_field("statement"));
7773 }
7774 statement__ = Some(map_.next_value()?);
7775 }
7776 GeneratedField::Progress => {
7777 if progress__.is_some() {
7778 return Err(serde::de::Error::duplicate_field("progress"));
7779 }
7780 progress__ = Some(map_.next_value()?);
7781 }
7782 GeneratedField::CreateType => {
7783 if create_type__.is_some() {
7784 return Err(serde::de::Error::duplicate_field("createType"));
7785 }
7786 create_type__ = Some(map_.next_value()?);
7787 }
7788 GeneratedField::InitializedAtTimeMillis => {
7789 if initialized_at_time_millis__.is_some() {
7790 return Err(serde::de::Error::duplicate_field("initializedAtTimeMillis"));
7791 }
7792 initialized_at_time_millis__ =
7793 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7794 ;
7795 }
7796 GeneratedField::IsServerlessBackfill => {
7797 if is_serverless_backfill__.is_some() {
7798 return Err(serde::de::Error::duplicate_field("isServerlessBackfill"));
7799 }
7800 is_serverless_backfill__ = Some(map_.next_value()?);
7801 }
7802 GeneratedField::BackfillType => {
7803 if backfill_type__.is_some() {
7804 return Err(serde::de::Error::duplicate_field("backfillType"));
7805 }
7806 backfill_type__ = Some(map_.next_value::<BackfillType>()? as i32);
7807 }
7808 }
7809 }
7810 Ok(DdlProgress {
7811 id: id__.unwrap_or_default(),
7812 statement: statement__.unwrap_or_default(),
7813 progress: progress__.unwrap_or_default(),
7814 create_type: create_type__.unwrap_or_default(),
7815 initialized_at_time_millis: initialized_at_time_millis__.unwrap_or_default(),
7816 is_serverless_backfill: is_serverless_backfill__.unwrap_or_default(),
7817 backfill_type: backfill_type__.unwrap_or_default(),
7818 })
7819 }
7820 }
7821 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
7822 }
7823}
7824impl serde::Serialize for DropConnectionRequest {
7825 #[allow(deprecated)]
7826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7827 where
7828 S: serde::Serializer,
7829 {
7830 use serde::ser::SerializeStruct;
7831 let mut len = 0;
7832 if self.connection_id != 0 {
7833 len += 1;
7834 }
7835 if self.cascade {
7836 len += 1;
7837 }
7838 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
7839 if self.connection_id != 0 {
7840 struct_ser.serialize_field("connectionId", &self.connection_id)?;
7841 }
7842 if self.cascade {
7843 struct_ser.serialize_field("cascade", &self.cascade)?;
7844 }
7845 struct_ser.end()
7846 }
7847}
7848impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
7849 #[allow(deprecated)]
7850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7851 where
7852 D: serde::Deserializer<'de>,
7853 {
7854 const FIELDS: &[&str] = &[
7855 "connection_id",
7856 "connectionId",
7857 "cascade",
7858 ];
7859
7860 #[allow(clippy::enum_variant_names)]
7861 enum GeneratedField {
7862 ConnectionId,
7863 Cascade,
7864 }
7865 impl<'de> serde::Deserialize<'de> for GeneratedField {
7866 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7867 where
7868 D: serde::Deserializer<'de>,
7869 {
7870 struct GeneratedVisitor;
7871
7872 impl serde::de::Visitor<'_> for GeneratedVisitor {
7873 type Value = GeneratedField;
7874
7875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7876 write!(formatter, "expected one of: {:?}", &FIELDS)
7877 }
7878
7879 #[allow(unused_variables)]
7880 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7881 where
7882 E: serde::de::Error,
7883 {
7884 match value {
7885 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
7886 "cascade" => Ok(GeneratedField::Cascade),
7887 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7888 }
7889 }
7890 }
7891 deserializer.deserialize_identifier(GeneratedVisitor)
7892 }
7893 }
7894 struct GeneratedVisitor;
7895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7896 type Value = DropConnectionRequest;
7897
7898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7899 formatter.write_str("struct ddl_service.DropConnectionRequest")
7900 }
7901
7902 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
7903 where
7904 V: serde::de::MapAccess<'de>,
7905 {
7906 let mut connection_id__ = None;
7907 let mut cascade__ = None;
7908 while let Some(k) = map_.next_key()? {
7909 match k {
7910 GeneratedField::ConnectionId => {
7911 if connection_id__.is_some() {
7912 return Err(serde::de::Error::duplicate_field("connectionId"));
7913 }
7914 connection_id__ =
7915 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7916 ;
7917 }
7918 GeneratedField::Cascade => {
7919 if cascade__.is_some() {
7920 return Err(serde::de::Error::duplicate_field("cascade"));
7921 }
7922 cascade__ = Some(map_.next_value()?);
7923 }
7924 }
7925 }
7926 Ok(DropConnectionRequest {
7927 connection_id: connection_id__.unwrap_or_default(),
7928 cascade: cascade__.unwrap_or_default(),
7929 })
7930 }
7931 }
7932 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
7933 }
7934}
7935impl serde::Serialize for DropConnectionResponse {
7936 #[allow(deprecated)]
7937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7938 where
7939 S: serde::Serializer,
7940 {
7941 use serde::ser::SerializeStruct;
7942 let mut len = 0;
7943 if self.status.is_some() {
7944 len += 1;
7945 }
7946 if self.version.is_some() {
7947 len += 1;
7948 }
7949 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
7950 if let Some(v) = self.status.as_ref() {
7951 struct_ser.serialize_field("status", v)?;
7952 }
7953 if let Some(v) = self.version.as_ref() {
7954 struct_ser.serialize_field("version", v)?;
7955 }
7956 struct_ser.end()
7957 }
7958}
7959impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
7960 #[allow(deprecated)]
7961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7962 where
7963 D: serde::Deserializer<'de>,
7964 {
7965 const FIELDS: &[&str] = &[
7966 "status",
7967 "version",
7968 ];
7969
7970 #[allow(clippy::enum_variant_names)]
7971 enum GeneratedField {
7972 Status,
7973 Version,
7974 }
7975 impl<'de> serde::Deserialize<'de> for GeneratedField {
7976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7977 where
7978 D: serde::Deserializer<'de>,
7979 {
7980 struct GeneratedVisitor;
7981
7982 impl serde::de::Visitor<'_> for GeneratedVisitor {
7983 type Value = GeneratedField;
7984
7985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7986 write!(formatter, "expected one of: {:?}", &FIELDS)
7987 }
7988
7989 #[allow(unused_variables)]
7990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7991 where
7992 E: serde::de::Error,
7993 {
7994 match value {
7995 "status" => Ok(GeneratedField::Status),
7996 "version" => Ok(GeneratedField::Version),
7997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7998 }
7999 }
8000 }
8001 deserializer.deserialize_identifier(GeneratedVisitor)
8002 }
8003 }
8004 struct GeneratedVisitor;
8005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8006 type Value = DropConnectionResponse;
8007
8008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8009 formatter.write_str("struct ddl_service.DropConnectionResponse")
8010 }
8011
8012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
8013 where
8014 V: serde::de::MapAccess<'de>,
8015 {
8016 let mut status__ = None;
8017 let mut version__ = None;
8018 while let Some(k) = map_.next_key()? {
8019 match k {
8020 GeneratedField::Status => {
8021 if status__.is_some() {
8022 return Err(serde::de::Error::duplicate_field("status"));
8023 }
8024 status__ = map_.next_value()?;
8025 }
8026 GeneratedField::Version => {
8027 if version__.is_some() {
8028 return Err(serde::de::Error::duplicate_field("version"));
8029 }
8030 version__ = map_.next_value()?;
8031 }
8032 }
8033 }
8034 Ok(DropConnectionResponse {
8035 status: status__,
8036 version: version__,
8037 })
8038 }
8039 }
8040 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
8041 }
8042}
8043impl serde::Serialize for DropDatabaseRequest {
8044 #[allow(deprecated)]
8045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8046 where
8047 S: serde::Serializer,
8048 {
8049 use serde::ser::SerializeStruct;
8050 let mut len = 0;
8051 if self.database_id != 0 {
8052 len += 1;
8053 }
8054 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
8055 if self.database_id != 0 {
8056 struct_ser.serialize_field("databaseId", &self.database_id)?;
8057 }
8058 struct_ser.end()
8059 }
8060}
8061impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
8062 #[allow(deprecated)]
8063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8064 where
8065 D: serde::Deserializer<'de>,
8066 {
8067 const FIELDS: &[&str] = &[
8068 "database_id",
8069 "databaseId",
8070 ];
8071
8072 #[allow(clippy::enum_variant_names)]
8073 enum GeneratedField {
8074 DatabaseId,
8075 }
8076 impl<'de> serde::Deserialize<'de> for GeneratedField {
8077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8078 where
8079 D: serde::Deserializer<'de>,
8080 {
8081 struct GeneratedVisitor;
8082
8083 impl serde::de::Visitor<'_> for GeneratedVisitor {
8084 type Value = GeneratedField;
8085
8086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087 write!(formatter, "expected one of: {:?}", &FIELDS)
8088 }
8089
8090 #[allow(unused_variables)]
8091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8092 where
8093 E: serde::de::Error,
8094 {
8095 match value {
8096 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
8097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8098 }
8099 }
8100 }
8101 deserializer.deserialize_identifier(GeneratedVisitor)
8102 }
8103 }
8104 struct GeneratedVisitor;
8105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8106 type Value = DropDatabaseRequest;
8107
8108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8109 formatter.write_str("struct ddl_service.DropDatabaseRequest")
8110 }
8111
8112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
8113 where
8114 V: serde::de::MapAccess<'de>,
8115 {
8116 let mut database_id__ = None;
8117 while let Some(k) = map_.next_key()? {
8118 match k {
8119 GeneratedField::DatabaseId => {
8120 if database_id__.is_some() {
8121 return Err(serde::de::Error::duplicate_field("databaseId"));
8122 }
8123 database_id__ =
8124 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8125 ;
8126 }
8127 }
8128 }
8129 Ok(DropDatabaseRequest {
8130 database_id: database_id__.unwrap_or_default(),
8131 })
8132 }
8133 }
8134 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
8135 }
8136}
8137impl serde::Serialize for DropDatabaseResponse {
8138 #[allow(deprecated)]
8139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8140 where
8141 S: serde::Serializer,
8142 {
8143 use serde::ser::SerializeStruct;
8144 let mut len = 0;
8145 if self.status.is_some() {
8146 len += 1;
8147 }
8148 if self.version.is_some() {
8149 len += 1;
8150 }
8151 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
8152 if let Some(v) = self.status.as_ref() {
8153 struct_ser.serialize_field("status", v)?;
8154 }
8155 if let Some(v) = self.version.as_ref() {
8156 struct_ser.serialize_field("version", v)?;
8157 }
8158 struct_ser.end()
8159 }
8160}
8161impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
8162 #[allow(deprecated)]
8163 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8164 where
8165 D: serde::Deserializer<'de>,
8166 {
8167 const FIELDS: &[&str] = &[
8168 "status",
8169 "version",
8170 ];
8171
8172 #[allow(clippy::enum_variant_names)]
8173 enum GeneratedField {
8174 Status,
8175 Version,
8176 }
8177 impl<'de> serde::Deserialize<'de> for GeneratedField {
8178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8179 where
8180 D: serde::Deserializer<'de>,
8181 {
8182 struct GeneratedVisitor;
8183
8184 impl serde::de::Visitor<'_> for GeneratedVisitor {
8185 type Value = GeneratedField;
8186
8187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8188 write!(formatter, "expected one of: {:?}", &FIELDS)
8189 }
8190
8191 #[allow(unused_variables)]
8192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8193 where
8194 E: serde::de::Error,
8195 {
8196 match value {
8197 "status" => Ok(GeneratedField::Status),
8198 "version" => Ok(GeneratedField::Version),
8199 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8200 }
8201 }
8202 }
8203 deserializer.deserialize_identifier(GeneratedVisitor)
8204 }
8205 }
8206 struct GeneratedVisitor;
8207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8208 type Value = DropDatabaseResponse;
8209
8210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8211 formatter.write_str("struct ddl_service.DropDatabaseResponse")
8212 }
8213
8214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
8215 where
8216 V: serde::de::MapAccess<'de>,
8217 {
8218 let mut status__ = None;
8219 let mut version__ = None;
8220 while let Some(k) = map_.next_key()? {
8221 match k {
8222 GeneratedField::Status => {
8223 if status__.is_some() {
8224 return Err(serde::de::Error::duplicate_field("status"));
8225 }
8226 status__ = map_.next_value()?;
8227 }
8228 GeneratedField::Version => {
8229 if version__.is_some() {
8230 return Err(serde::de::Error::duplicate_field("version"));
8231 }
8232 version__ = map_.next_value()?;
8233 }
8234 }
8235 }
8236 Ok(DropDatabaseResponse {
8237 status: status__,
8238 version: version__,
8239 })
8240 }
8241 }
8242 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
8243 }
8244}
8245impl serde::Serialize for DropFunctionRequest {
8246 #[allow(deprecated)]
8247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8248 where
8249 S: serde::Serializer,
8250 {
8251 use serde::ser::SerializeStruct;
8252 let mut len = 0;
8253 if self.function_id != 0 {
8254 len += 1;
8255 }
8256 if self.cascade {
8257 len += 1;
8258 }
8259 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
8260 if self.function_id != 0 {
8261 struct_ser.serialize_field("functionId", &self.function_id)?;
8262 }
8263 if self.cascade {
8264 struct_ser.serialize_field("cascade", &self.cascade)?;
8265 }
8266 struct_ser.end()
8267 }
8268}
8269impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
8270 #[allow(deprecated)]
8271 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8272 where
8273 D: serde::Deserializer<'de>,
8274 {
8275 const FIELDS: &[&str] = &[
8276 "function_id",
8277 "functionId",
8278 "cascade",
8279 ];
8280
8281 #[allow(clippy::enum_variant_names)]
8282 enum GeneratedField {
8283 FunctionId,
8284 Cascade,
8285 }
8286 impl<'de> serde::Deserialize<'de> for GeneratedField {
8287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8288 where
8289 D: serde::Deserializer<'de>,
8290 {
8291 struct GeneratedVisitor;
8292
8293 impl serde::de::Visitor<'_> for GeneratedVisitor {
8294 type Value = GeneratedField;
8295
8296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8297 write!(formatter, "expected one of: {:?}", &FIELDS)
8298 }
8299
8300 #[allow(unused_variables)]
8301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8302 where
8303 E: serde::de::Error,
8304 {
8305 match value {
8306 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
8307 "cascade" => Ok(GeneratedField::Cascade),
8308 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8309 }
8310 }
8311 }
8312 deserializer.deserialize_identifier(GeneratedVisitor)
8313 }
8314 }
8315 struct GeneratedVisitor;
8316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8317 type Value = DropFunctionRequest;
8318
8319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8320 formatter.write_str("struct ddl_service.DropFunctionRequest")
8321 }
8322
8323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
8324 where
8325 V: serde::de::MapAccess<'de>,
8326 {
8327 let mut function_id__ = None;
8328 let mut cascade__ = None;
8329 while let Some(k) = map_.next_key()? {
8330 match k {
8331 GeneratedField::FunctionId => {
8332 if function_id__.is_some() {
8333 return Err(serde::de::Error::duplicate_field("functionId"));
8334 }
8335 function_id__ =
8336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8337 ;
8338 }
8339 GeneratedField::Cascade => {
8340 if cascade__.is_some() {
8341 return Err(serde::de::Error::duplicate_field("cascade"));
8342 }
8343 cascade__ = Some(map_.next_value()?);
8344 }
8345 }
8346 }
8347 Ok(DropFunctionRequest {
8348 function_id: function_id__.unwrap_or_default(),
8349 cascade: cascade__.unwrap_or_default(),
8350 })
8351 }
8352 }
8353 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
8354 }
8355}
8356impl serde::Serialize for DropFunctionResponse {
8357 #[allow(deprecated)]
8358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8359 where
8360 S: serde::Serializer,
8361 {
8362 use serde::ser::SerializeStruct;
8363 let mut len = 0;
8364 if self.status.is_some() {
8365 len += 1;
8366 }
8367 if self.version.is_some() {
8368 len += 1;
8369 }
8370 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
8371 if let Some(v) = self.status.as_ref() {
8372 struct_ser.serialize_field("status", v)?;
8373 }
8374 if let Some(v) = self.version.as_ref() {
8375 struct_ser.serialize_field("version", v)?;
8376 }
8377 struct_ser.end()
8378 }
8379}
8380impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
8381 #[allow(deprecated)]
8382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8383 where
8384 D: serde::Deserializer<'de>,
8385 {
8386 const FIELDS: &[&str] = &[
8387 "status",
8388 "version",
8389 ];
8390
8391 #[allow(clippy::enum_variant_names)]
8392 enum GeneratedField {
8393 Status,
8394 Version,
8395 }
8396 impl<'de> serde::Deserialize<'de> for GeneratedField {
8397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8398 where
8399 D: serde::Deserializer<'de>,
8400 {
8401 struct GeneratedVisitor;
8402
8403 impl serde::de::Visitor<'_> for GeneratedVisitor {
8404 type Value = GeneratedField;
8405
8406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8407 write!(formatter, "expected one of: {:?}", &FIELDS)
8408 }
8409
8410 #[allow(unused_variables)]
8411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8412 where
8413 E: serde::de::Error,
8414 {
8415 match value {
8416 "status" => Ok(GeneratedField::Status),
8417 "version" => Ok(GeneratedField::Version),
8418 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8419 }
8420 }
8421 }
8422 deserializer.deserialize_identifier(GeneratedVisitor)
8423 }
8424 }
8425 struct GeneratedVisitor;
8426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8427 type Value = DropFunctionResponse;
8428
8429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8430 formatter.write_str("struct ddl_service.DropFunctionResponse")
8431 }
8432
8433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
8434 where
8435 V: serde::de::MapAccess<'de>,
8436 {
8437 let mut status__ = None;
8438 let mut version__ = None;
8439 while let Some(k) = map_.next_key()? {
8440 match k {
8441 GeneratedField::Status => {
8442 if status__.is_some() {
8443 return Err(serde::de::Error::duplicate_field("status"));
8444 }
8445 status__ = map_.next_value()?;
8446 }
8447 GeneratedField::Version => {
8448 if version__.is_some() {
8449 return Err(serde::de::Error::duplicate_field("version"));
8450 }
8451 version__ = map_.next_value()?;
8452 }
8453 }
8454 }
8455 Ok(DropFunctionResponse {
8456 status: status__,
8457 version: version__,
8458 })
8459 }
8460 }
8461 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
8462 }
8463}
8464impl serde::Serialize for DropIndexRequest {
8465 #[allow(deprecated)]
8466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8467 where
8468 S: serde::Serializer,
8469 {
8470 use serde::ser::SerializeStruct;
8471 let mut len = 0;
8472 if self.index_id != 0 {
8473 len += 1;
8474 }
8475 if self.cascade {
8476 len += 1;
8477 }
8478 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
8479 if self.index_id != 0 {
8480 struct_ser.serialize_field("indexId", &self.index_id)?;
8481 }
8482 if self.cascade {
8483 struct_ser.serialize_field("cascade", &self.cascade)?;
8484 }
8485 struct_ser.end()
8486 }
8487}
8488impl<'de> serde::Deserialize<'de> for DropIndexRequest {
8489 #[allow(deprecated)]
8490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8491 where
8492 D: serde::Deserializer<'de>,
8493 {
8494 const FIELDS: &[&str] = &[
8495 "index_id",
8496 "indexId",
8497 "cascade",
8498 ];
8499
8500 #[allow(clippy::enum_variant_names)]
8501 enum GeneratedField {
8502 IndexId,
8503 Cascade,
8504 }
8505 impl<'de> serde::Deserialize<'de> for GeneratedField {
8506 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8507 where
8508 D: serde::Deserializer<'de>,
8509 {
8510 struct GeneratedVisitor;
8511
8512 impl serde::de::Visitor<'_> for GeneratedVisitor {
8513 type Value = GeneratedField;
8514
8515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8516 write!(formatter, "expected one of: {:?}", &FIELDS)
8517 }
8518
8519 #[allow(unused_variables)]
8520 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8521 where
8522 E: serde::de::Error,
8523 {
8524 match value {
8525 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8526 "cascade" => Ok(GeneratedField::Cascade),
8527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8528 }
8529 }
8530 }
8531 deserializer.deserialize_identifier(GeneratedVisitor)
8532 }
8533 }
8534 struct GeneratedVisitor;
8535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8536 type Value = DropIndexRequest;
8537
8538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8539 formatter.write_str("struct ddl_service.DropIndexRequest")
8540 }
8541
8542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8543 where
8544 V: serde::de::MapAccess<'de>,
8545 {
8546 let mut index_id__ = None;
8547 let mut cascade__ = None;
8548 while let Some(k) = map_.next_key()? {
8549 match k {
8550 GeneratedField::IndexId => {
8551 if index_id__.is_some() {
8552 return Err(serde::de::Error::duplicate_field("indexId"));
8553 }
8554 index_id__ =
8555 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8556 ;
8557 }
8558 GeneratedField::Cascade => {
8559 if cascade__.is_some() {
8560 return Err(serde::de::Error::duplicate_field("cascade"));
8561 }
8562 cascade__ = Some(map_.next_value()?);
8563 }
8564 }
8565 }
8566 Ok(DropIndexRequest {
8567 index_id: index_id__.unwrap_or_default(),
8568 cascade: cascade__.unwrap_or_default(),
8569 })
8570 }
8571 }
8572 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8573 }
8574}
8575impl serde::Serialize for DropIndexResponse {
8576 #[allow(deprecated)]
8577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8578 where
8579 S: serde::Serializer,
8580 {
8581 use serde::ser::SerializeStruct;
8582 let mut len = 0;
8583 if self.status.is_some() {
8584 len += 1;
8585 }
8586 if self.version.is_some() {
8587 len += 1;
8588 }
8589 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8590 if let Some(v) = self.status.as_ref() {
8591 struct_ser.serialize_field("status", v)?;
8592 }
8593 if let Some(v) = self.version.as_ref() {
8594 struct_ser.serialize_field("version", v)?;
8595 }
8596 struct_ser.end()
8597 }
8598}
8599impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8600 #[allow(deprecated)]
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 const FIELDS: &[&str] = &[
8606 "status",
8607 "version",
8608 ];
8609
8610 #[allow(clippy::enum_variant_names)]
8611 enum GeneratedField {
8612 Status,
8613 Version,
8614 }
8615 impl<'de> serde::Deserialize<'de> for GeneratedField {
8616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8617 where
8618 D: serde::Deserializer<'de>,
8619 {
8620 struct GeneratedVisitor;
8621
8622 impl serde::de::Visitor<'_> for GeneratedVisitor {
8623 type Value = GeneratedField;
8624
8625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8626 write!(formatter, "expected one of: {:?}", &FIELDS)
8627 }
8628
8629 #[allow(unused_variables)]
8630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8631 where
8632 E: serde::de::Error,
8633 {
8634 match value {
8635 "status" => Ok(GeneratedField::Status),
8636 "version" => Ok(GeneratedField::Version),
8637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8638 }
8639 }
8640 }
8641 deserializer.deserialize_identifier(GeneratedVisitor)
8642 }
8643 }
8644 struct GeneratedVisitor;
8645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8646 type Value = DropIndexResponse;
8647
8648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8649 formatter.write_str("struct ddl_service.DropIndexResponse")
8650 }
8651
8652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
8653 where
8654 V: serde::de::MapAccess<'de>,
8655 {
8656 let mut status__ = None;
8657 let mut version__ = None;
8658 while let Some(k) = map_.next_key()? {
8659 match k {
8660 GeneratedField::Status => {
8661 if status__.is_some() {
8662 return Err(serde::de::Error::duplicate_field("status"));
8663 }
8664 status__ = map_.next_value()?;
8665 }
8666 GeneratedField::Version => {
8667 if version__.is_some() {
8668 return Err(serde::de::Error::duplicate_field("version"));
8669 }
8670 version__ = map_.next_value()?;
8671 }
8672 }
8673 }
8674 Ok(DropIndexResponse {
8675 status: status__,
8676 version: version__,
8677 })
8678 }
8679 }
8680 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
8681 }
8682}
8683impl serde::Serialize for DropMaterializedViewRequest {
8684 #[allow(deprecated)]
8685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8686 where
8687 S: serde::Serializer,
8688 {
8689 use serde::ser::SerializeStruct;
8690 let mut len = 0;
8691 if self.table_id != 0 {
8692 len += 1;
8693 }
8694 if self.cascade {
8695 len += 1;
8696 }
8697 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
8698 if self.table_id != 0 {
8699 struct_ser.serialize_field("tableId", &self.table_id)?;
8700 }
8701 if self.cascade {
8702 struct_ser.serialize_field("cascade", &self.cascade)?;
8703 }
8704 struct_ser.end()
8705 }
8706}
8707impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
8708 #[allow(deprecated)]
8709 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8710 where
8711 D: serde::Deserializer<'de>,
8712 {
8713 const FIELDS: &[&str] = &[
8714 "table_id",
8715 "tableId",
8716 "cascade",
8717 ];
8718
8719 #[allow(clippy::enum_variant_names)]
8720 enum GeneratedField {
8721 TableId,
8722 Cascade,
8723 }
8724 impl<'de> serde::Deserialize<'de> for GeneratedField {
8725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8726 where
8727 D: serde::Deserializer<'de>,
8728 {
8729 struct GeneratedVisitor;
8730
8731 impl serde::de::Visitor<'_> for GeneratedVisitor {
8732 type Value = GeneratedField;
8733
8734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8735 write!(formatter, "expected one of: {:?}", &FIELDS)
8736 }
8737
8738 #[allow(unused_variables)]
8739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8740 where
8741 E: serde::de::Error,
8742 {
8743 match value {
8744 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8745 "cascade" => Ok(GeneratedField::Cascade),
8746 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8747 }
8748 }
8749 }
8750 deserializer.deserialize_identifier(GeneratedVisitor)
8751 }
8752 }
8753 struct GeneratedVisitor;
8754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8755 type Value = DropMaterializedViewRequest;
8756
8757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8758 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
8759 }
8760
8761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
8762 where
8763 V: serde::de::MapAccess<'de>,
8764 {
8765 let mut table_id__ = None;
8766 let mut cascade__ = None;
8767 while let Some(k) = map_.next_key()? {
8768 match k {
8769 GeneratedField::TableId => {
8770 if table_id__.is_some() {
8771 return Err(serde::de::Error::duplicate_field("tableId"));
8772 }
8773 table_id__ =
8774 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8775 ;
8776 }
8777 GeneratedField::Cascade => {
8778 if cascade__.is_some() {
8779 return Err(serde::de::Error::duplicate_field("cascade"));
8780 }
8781 cascade__ = Some(map_.next_value()?);
8782 }
8783 }
8784 }
8785 Ok(DropMaterializedViewRequest {
8786 table_id: table_id__.unwrap_or_default(),
8787 cascade: cascade__.unwrap_or_default(),
8788 })
8789 }
8790 }
8791 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
8792 }
8793}
8794impl serde::Serialize for DropMaterializedViewResponse {
8795 #[allow(deprecated)]
8796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8797 where
8798 S: serde::Serializer,
8799 {
8800 use serde::ser::SerializeStruct;
8801 let mut len = 0;
8802 if self.status.is_some() {
8803 len += 1;
8804 }
8805 if self.version.is_some() {
8806 len += 1;
8807 }
8808 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
8809 if let Some(v) = self.status.as_ref() {
8810 struct_ser.serialize_field("status", v)?;
8811 }
8812 if let Some(v) = self.version.as_ref() {
8813 struct_ser.serialize_field("version", v)?;
8814 }
8815 struct_ser.end()
8816 }
8817}
8818impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
8819 #[allow(deprecated)]
8820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8821 where
8822 D: serde::Deserializer<'de>,
8823 {
8824 const FIELDS: &[&str] = &[
8825 "status",
8826 "version",
8827 ];
8828
8829 #[allow(clippy::enum_variant_names)]
8830 enum GeneratedField {
8831 Status,
8832 Version,
8833 }
8834 impl<'de> serde::Deserialize<'de> for GeneratedField {
8835 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8836 where
8837 D: serde::Deserializer<'de>,
8838 {
8839 struct GeneratedVisitor;
8840
8841 impl serde::de::Visitor<'_> for GeneratedVisitor {
8842 type Value = GeneratedField;
8843
8844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8845 write!(formatter, "expected one of: {:?}", &FIELDS)
8846 }
8847
8848 #[allow(unused_variables)]
8849 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8850 where
8851 E: serde::de::Error,
8852 {
8853 match value {
8854 "status" => Ok(GeneratedField::Status),
8855 "version" => Ok(GeneratedField::Version),
8856 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8857 }
8858 }
8859 }
8860 deserializer.deserialize_identifier(GeneratedVisitor)
8861 }
8862 }
8863 struct GeneratedVisitor;
8864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8865 type Value = DropMaterializedViewResponse;
8866
8867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8868 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
8869 }
8870
8871 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
8872 where
8873 V: serde::de::MapAccess<'de>,
8874 {
8875 let mut status__ = None;
8876 let mut version__ = None;
8877 while let Some(k) = map_.next_key()? {
8878 match k {
8879 GeneratedField::Status => {
8880 if status__.is_some() {
8881 return Err(serde::de::Error::duplicate_field("status"));
8882 }
8883 status__ = map_.next_value()?;
8884 }
8885 GeneratedField::Version => {
8886 if version__.is_some() {
8887 return Err(serde::de::Error::duplicate_field("version"));
8888 }
8889 version__ = map_.next_value()?;
8890 }
8891 }
8892 }
8893 Ok(DropMaterializedViewResponse {
8894 status: status__,
8895 version: version__,
8896 })
8897 }
8898 }
8899 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
8900 }
8901}
8902impl serde::Serialize for DropSchemaRequest {
8903 #[allow(deprecated)]
8904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8905 where
8906 S: serde::Serializer,
8907 {
8908 use serde::ser::SerializeStruct;
8909 let mut len = 0;
8910 if self.schema_id != 0 {
8911 len += 1;
8912 }
8913 if self.cascade {
8914 len += 1;
8915 }
8916 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
8917 if self.schema_id != 0 {
8918 struct_ser.serialize_field("schemaId", &self.schema_id)?;
8919 }
8920 if self.cascade {
8921 struct_ser.serialize_field("cascade", &self.cascade)?;
8922 }
8923 struct_ser.end()
8924 }
8925}
8926impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
8927 #[allow(deprecated)]
8928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8929 where
8930 D: serde::Deserializer<'de>,
8931 {
8932 const FIELDS: &[&str] = &[
8933 "schema_id",
8934 "schemaId",
8935 "cascade",
8936 ];
8937
8938 #[allow(clippy::enum_variant_names)]
8939 enum GeneratedField {
8940 SchemaId,
8941 Cascade,
8942 }
8943 impl<'de> serde::Deserialize<'de> for GeneratedField {
8944 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8945 where
8946 D: serde::Deserializer<'de>,
8947 {
8948 struct GeneratedVisitor;
8949
8950 impl serde::de::Visitor<'_> for GeneratedVisitor {
8951 type Value = GeneratedField;
8952
8953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8954 write!(formatter, "expected one of: {:?}", &FIELDS)
8955 }
8956
8957 #[allow(unused_variables)]
8958 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8959 where
8960 E: serde::de::Error,
8961 {
8962 match value {
8963 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
8964 "cascade" => Ok(GeneratedField::Cascade),
8965 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8966 }
8967 }
8968 }
8969 deserializer.deserialize_identifier(GeneratedVisitor)
8970 }
8971 }
8972 struct GeneratedVisitor;
8973 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8974 type Value = DropSchemaRequest;
8975
8976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8977 formatter.write_str("struct ddl_service.DropSchemaRequest")
8978 }
8979
8980 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
8981 where
8982 V: serde::de::MapAccess<'de>,
8983 {
8984 let mut schema_id__ = None;
8985 let mut cascade__ = None;
8986 while let Some(k) = map_.next_key()? {
8987 match k {
8988 GeneratedField::SchemaId => {
8989 if schema_id__.is_some() {
8990 return Err(serde::de::Error::duplicate_field("schemaId"));
8991 }
8992 schema_id__ =
8993 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8994 ;
8995 }
8996 GeneratedField::Cascade => {
8997 if cascade__.is_some() {
8998 return Err(serde::de::Error::duplicate_field("cascade"));
8999 }
9000 cascade__ = Some(map_.next_value()?);
9001 }
9002 }
9003 }
9004 Ok(DropSchemaRequest {
9005 schema_id: schema_id__.unwrap_or_default(),
9006 cascade: cascade__.unwrap_or_default(),
9007 })
9008 }
9009 }
9010 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
9011 }
9012}
9013impl serde::Serialize for DropSchemaResponse {
9014 #[allow(deprecated)]
9015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9016 where
9017 S: serde::Serializer,
9018 {
9019 use serde::ser::SerializeStruct;
9020 let mut len = 0;
9021 if self.status.is_some() {
9022 len += 1;
9023 }
9024 if self.version.is_some() {
9025 len += 1;
9026 }
9027 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
9028 if let Some(v) = self.status.as_ref() {
9029 struct_ser.serialize_field("status", v)?;
9030 }
9031 if let Some(v) = self.version.as_ref() {
9032 struct_ser.serialize_field("version", v)?;
9033 }
9034 struct_ser.end()
9035 }
9036}
9037impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
9038 #[allow(deprecated)]
9039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9040 where
9041 D: serde::Deserializer<'de>,
9042 {
9043 const FIELDS: &[&str] = &[
9044 "status",
9045 "version",
9046 ];
9047
9048 #[allow(clippy::enum_variant_names)]
9049 enum GeneratedField {
9050 Status,
9051 Version,
9052 }
9053 impl<'de> serde::Deserialize<'de> for GeneratedField {
9054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9055 where
9056 D: serde::Deserializer<'de>,
9057 {
9058 struct GeneratedVisitor;
9059
9060 impl serde::de::Visitor<'_> for GeneratedVisitor {
9061 type Value = GeneratedField;
9062
9063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9064 write!(formatter, "expected one of: {:?}", &FIELDS)
9065 }
9066
9067 #[allow(unused_variables)]
9068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9069 where
9070 E: serde::de::Error,
9071 {
9072 match value {
9073 "status" => Ok(GeneratedField::Status),
9074 "version" => Ok(GeneratedField::Version),
9075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9076 }
9077 }
9078 }
9079 deserializer.deserialize_identifier(GeneratedVisitor)
9080 }
9081 }
9082 struct GeneratedVisitor;
9083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084 type Value = DropSchemaResponse;
9085
9086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087 formatter.write_str("struct ddl_service.DropSchemaResponse")
9088 }
9089
9090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
9091 where
9092 V: serde::de::MapAccess<'de>,
9093 {
9094 let mut status__ = None;
9095 let mut version__ = None;
9096 while let Some(k) = map_.next_key()? {
9097 match k {
9098 GeneratedField::Status => {
9099 if status__.is_some() {
9100 return Err(serde::de::Error::duplicate_field("status"));
9101 }
9102 status__ = map_.next_value()?;
9103 }
9104 GeneratedField::Version => {
9105 if version__.is_some() {
9106 return Err(serde::de::Error::duplicate_field("version"));
9107 }
9108 version__ = map_.next_value()?;
9109 }
9110 }
9111 }
9112 Ok(DropSchemaResponse {
9113 status: status__,
9114 version: version__,
9115 })
9116 }
9117 }
9118 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
9119 }
9120}
9121impl serde::Serialize for DropSecretRequest {
9122 #[allow(deprecated)]
9123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9124 where
9125 S: serde::Serializer,
9126 {
9127 use serde::ser::SerializeStruct;
9128 let mut len = 0;
9129 if self.secret_id != 0 {
9130 len += 1;
9131 }
9132 if self.cascade {
9133 len += 1;
9134 }
9135 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
9136 if self.secret_id != 0 {
9137 struct_ser.serialize_field("secretId", &self.secret_id)?;
9138 }
9139 if self.cascade {
9140 struct_ser.serialize_field("cascade", &self.cascade)?;
9141 }
9142 struct_ser.end()
9143 }
9144}
9145impl<'de> serde::Deserialize<'de> for DropSecretRequest {
9146 #[allow(deprecated)]
9147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9148 where
9149 D: serde::Deserializer<'de>,
9150 {
9151 const FIELDS: &[&str] = &[
9152 "secret_id",
9153 "secretId",
9154 "cascade",
9155 ];
9156
9157 #[allow(clippy::enum_variant_names)]
9158 enum GeneratedField {
9159 SecretId,
9160 Cascade,
9161 }
9162 impl<'de> serde::Deserialize<'de> for GeneratedField {
9163 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9164 where
9165 D: serde::Deserializer<'de>,
9166 {
9167 struct GeneratedVisitor;
9168
9169 impl serde::de::Visitor<'_> for GeneratedVisitor {
9170 type Value = GeneratedField;
9171
9172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9173 write!(formatter, "expected one of: {:?}", &FIELDS)
9174 }
9175
9176 #[allow(unused_variables)]
9177 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9178 where
9179 E: serde::de::Error,
9180 {
9181 match value {
9182 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
9183 "cascade" => Ok(GeneratedField::Cascade),
9184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9185 }
9186 }
9187 }
9188 deserializer.deserialize_identifier(GeneratedVisitor)
9189 }
9190 }
9191 struct GeneratedVisitor;
9192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9193 type Value = DropSecretRequest;
9194
9195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9196 formatter.write_str("struct ddl_service.DropSecretRequest")
9197 }
9198
9199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
9200 where
9201 V: serde::de::MapAccess<'de>,
9202 {
9203 let mut secret_id__ = None;
9204 let mut cascade__ = None;
9205 while let Some(k) = map_.next_key()? {
9206 match k {
9207 GeneratedField::SecretId => {
9208 if secret_id__.is_some() {
9209 return Err(serde::de::Error::duplicate_field("secretId"));
9210 }
9211 secret_id__ =
9212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9213 ;
9214 }
9215 GeneratedField::Cascade => {
9216 if cascade__.is_some() {
9217 return Err(serde::de::Error::duplicate_field("cascade"));
9218 }
9219 cascade__ = Some(map_.next_value()?);
9220 }
9221 }
9222 }
9223 Ok(DropSecretRequest {
9224 secret_id: secret_id__.unwrap_or_default(),
9225 cascade: cascade__.unwrap_or_default(),
9226 })
9227 }
9228 }
9229 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
9230 }
9231}
9232impl serde::Serialize for DropSecretResponse {
9233 #[allow(deprecated)]
9234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9235 where
9236 S: serde::Serializer,
9237 {
9238 use serde::ser::SerializeStruct;
9239 let mut len = 0;
9240 if self.version.is_some() {
9241 len += 1;
9242 }
9243 if self.status.is_some() {
9244 len += 1;
9245 }
9246 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
9247 if let Some(v) = self.version.as_ref() {
9248 struct_ser.serialize_field("version", v)?;
9249 }
9250 if let Some(v) = self.status.as_ref() {
9251 struct_ser.serialize_field("status", v)?;
9252 }
9253 struct_ser.end()
9254 }
9255}
9256impl<'de> serde::Deserialize<'de> for DropSecretResponse {
9257 #[allow(deprecated)]
9258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9259 where
9260 D: serde::Deserializer<'de>,
9261 {
9262 const FIELDS: &[&str] = &[
9263 "version",
9264 "status",
9265 ];
9266
9267 #[allow(clippy::enum_variant_names)]
9268 enum GeneratedField {
9269 Version,
9270 Status,
9271 }
9272 impl<'de> serde::Deserialize<'de> for GeneratedField {
9273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9274 where
9275 D: serde::Deserializer<'de>,
9276 {
9277 struct GeneratedVisitor;
9278
9279 impl serde::de::Visitor<'_> for GeneratedVisitor {
9280 type Value = GeneratedField;
9281
9282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9283 write!(formatter, "expected one of: {:?}", &FIELDS)
9284 }
9285
9286 #[allow(unused_variables)]
9287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9288 where
9289 E: serde::de::Error,
9290 {
9291 match value {
9292 "version" => Ok(GeneratedField::Version),
9293 "status" => Ok(GeneratedField::Status),
9294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9295 }
9296 }
9297 }
9298 deserializer.deserialize_identifier(GeneratedVisitor)
9299 }
9300 }
9301 struct GeneratedVisitor;
9302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9303 type Value = DropSecretResponse;
9304
9305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9306 formatter.write_str("struct ddl_service.DropSecretResponse")
9307 }
9308
9309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
9310 where
9311 V: serde::de::MapAccess<'de>,
9312 {
9313 let mut version__ = None;
9314 let mut status__ = None;
9315 while let Some(k) = map_.next_key()? {
9316 match k {
9317 GeneratedField::Version => {
9318 if version__.is_some() {
9319 return Err(serde::de::Error::duplicate_field("version"));
9320 }
9321 version__ = map_.next_value()?;
9322 }
9323 GeneratedField::Status => {
9324 if status__.is_some() {
9325 return Err(serde::de::Error::duplicate_field("status"));
9326 }
9327 status__ = map_.next_value()?;
9328 }
9329 }
9330 }
9331 Ok(DropSecretResponse {
9332 version: version__,
9333 status: status__,
9334 })
9335 }
9336 }
9337 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
9338 }
9339}
9340impl serde::Serialize for DropSinkRequest {
9341 #[allow(deprecated)]
9342 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9343 where
9344 S: serde::Serializer,
9345 {
9346 use serde::ser::SerializeStruct;
9347 let mut len = 0;
9348 if self.sink_id != 0 {
9349 len += 1;
9350 }
9351 if self.cascade {
9352 len += 1;
9353 }
9354 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
9355 if self.sink_id != 0 {
9356 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9357 }
9358 if self.cascade {
9359 struct_ser.serialize_field("cascade", &self.cascade)?;
9360 }
9361 struct_ser.end()
9362 }
9363}
9364impl<'de> serde::Deserialize<'de> for DropSinkRequest {
9365 #[allow(deprecated)]
9366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9367 where
9368 D: serde::Deserializer<'de>,
9369 {
9370 const FIELDS: &[&str] = &[
9371 "sink_id",
9372 "sinkId",
9373 "cascade",
9374 ];
9375
9376 #[allow(clippy::enum_variant_names)]
9377 enum GeneratedField {
9378 SinkId,
9379 Cascade,
9380 }
9381 impl<'de> serde::Deserialize<'de> for GeneratedField {
9382 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9383 where
9384 D: serde::Deserializer<'de>,
9385 {
9386 struct GeneratedVisitor;
9387
9388 impl serde::de::Visitor<'_> for GeneratedVisitor {
9389 type Value = GeneratedField;
9390
9391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9392 write!(formatter, "expected one of: {:?}", &FIELDS)
9393 }
9394
9395 #[allow(unused_variables)]
9396 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9397 where
9398 E: serde::de::Error,
9399 {
9400 match value {
9401 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9402 "cascade" => Ok(GeneratedField::Cascade),
9403 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9404 }
9405 }
9406 }
9407 deserializer.deserialize_identifier(GeneratedVisitor)
9408 }
9409 }
9410 struct GeneratedVisitor;
9411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9412 type Value = DropSinkRequest;
9413
9414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9415 formatter.write_str("struct ddl_service.DropSinkRequest")
9416 }
9417
9418 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
9419 where
9420 V: serde::de::MapAccess<'de>,
9421 {
9422 let mut sink_id__ = None;
9423 let mut cascade__ = None;
9424 while let Some(k) = map_.next_key()? {
9425 match k {
9426 GeneratedField::SinkId => {
9427 if sink_id__.is_some() {
9428 return Err(serde::de::Error::duplicate_field("sinkId"));
9429 }
9430 sink_id__ =
9431 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9432 ;
9433 }
9434 GeneratedField::Cascade => {
9435 if cascade__.is_some() {
9436 return Err(serde::de::Error::duplicate_field("cascade"));
9437 }
9438 cascade__ = Some(map_.next_value()?);
9439 }
9440 }
9441 }
9442 Ok(DropSinkRequest {
9443 sink_id: sink_id__.unwrap_or_default(),
9444 cascade: cascade__.unwrap_or_default(),
9445 })
9446 }
9447 }
9448 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
9449 }
9450}
9451impl serde::Serialize for DropSinkResponse {
9452 #[allow(deprecated)]
9453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9454 where
9455 S: serde::Serializer,
9456 {
9457 use serde::ser::SerializeStruct;
9458 let mut len = 0;
9459 if self.status.is_some() {
9460 len += 1;
9461 }
9462 if self.version.is_some() {
9463 len += 1;
9464 }
9465 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
9466 if let Some(v) = self.status.as_ref() {
9467 struct_ser.serialize_field("status", v)?;
9468 }
9469 if let Some(v) = self.version.as_ref() {
9470 struct_ser.serialize_field("version", v)?;
9471 }
9472 struct_ser.end()
9473 }
9474}
9475impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9476 #[allow(deprecated)]
9477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9478 where
9479 D: serde::Deserializer<'de>,
9480 {
9481 const FIELDS: &[&str] = &[
9482 "status",
9483 "version",
9484 ];
9485
9486 #[allow(clippy::enum_variant_names)]
9487 enum GeneratedField {
9488 Status,
9489 Version,
9490 }
9491 impl<'de> serde::Deserialize<'de> for GeneratedField {
9492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9493 where
9494 D: serde::Deserializer<'de>,
9495 {
9496 struct GeneratedVisitor;
9497
9498 impl serde::de::Visitor<'_> for GeneratedVisitor {
9499 type Value = GeneratedField;
9500
9501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9502 write!(formatter, "expected one of: {:?}", &FIELDS)
9503 }
9504
9505 #[allow(unused_variables)]
9506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9507 where
9508 E: serde::de::Error,
9509 {
9510 match value {
9511 "status" => Ok(GeneratedField::Status),
9512 "version" => Ok(GeneratedField::Version),
9513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9514 }
9515 }
9516 }
9517 deserializer.deserialize_identifier(GeneratedVisitor)
9518 }
9519 }
9520 struct GeneratedVisitor;
9521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9522 type Value = DropSinkResponse;
9523
9524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9525 formatter.write_str("struct ddl_service.DropSinkResponse")
9526 }
9527
9528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9529 where
9530 V: serde::de::MapAccess<'de>,
9531 {
9532 let mut status__ = None;
9533 let mut version__ = None;
9534 while let Some(k) = map_.next_key()? {
9535 match k {
9536 GeneratedField::Status => {
9537 if status__.is_some() {
9538 return Err(serde::de::Error::duplicate_field("status"));
9539 }
9540 status__ = map_.next_value()?;
9541 }
9542 GeneratedField::Version => {
9543 if version__.is_some() {
9544 return Err(serde::de::Error::duplicate_field("version"));
9545 }
9546 version__ = map_.next_value()?;
9547 }
9548 }
9549 }
9550 Ok(DropSinkResponse {
9551 status: status__,
9552 version: version__,
9553 })
9554 }
9555 }
9556 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9557 }
9558}
9559impl serde::Serialize for DropSourceRequest {
9560 #[allow(deprecated)]
9561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9562 where
9563 S: serde::Serializer,
9564 {
9565 use serde::ser::SerializeStruct;
9566 let mut len = 0;
9567 if self.source_id != 0 {
9568 len += 1;
9569 }
9570 if self.cascade {
9571 len += 1;
9572 }
9573 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9574 if self.source_id != 0 {
9575 struct_ser.serialize_field("sourceId", &self.source_id)?;
9576 }
9577 if self.cascade {
9578 struct_ser.serialize_field("cascade", &self.cascade)?;
9579 }
9580 struct_ser.end()
9581 }
9582}
9583impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9584 #[allow(deprecated)]
9585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9586 where
9587 D: serde::Deserializer<'de>,
9588 {
9589 const FIELDS: &[&str] = &[
9590 "source_id",
9591 "sourceId",
9592 "cascade",
9593 ];
9594
9595 #[allow(clippy::enum_variant_names)]
9596 enum GeneratedField {
9597 SourceId,
9598 Cascade,
9599 }
9600 impl<'de> serde::Deserialize<'de> for GeneratedField {
9601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9602 where
9603 D: serde::Deserializer<'de>,
9604 {
9605 struct GeneratedVisitor;
9606
9607 impl serde::de::Visitor<'_> for GeneratedVisitor {
9608 type Value = GeneratedField;
9609
9610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9611 write!(formatter, "expected one of: {:?}", &FIELDS)
9612 }
9613
9614 #[allow(unused_variables)]
9615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9616 where
9617 E: serde::de::Error,
9618 {
9619 match value {
9620 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9621 "cascade" => Ok(GeneratedField::Cascade),
9622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9623 }
9624 }
9625 }
9626 deserializer.deserialize_identifier(GeneratedVisitor)
9627 }
9628 }
9629 struct GeneratedVisitor;
9630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9631 type Value = DropSourceRequest;
9632
9633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9634 formatter.write_str("struct ddl_service.DropSourceRequest")
9635 }
9636
9637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9638 where
9639 V: serde::de::MapAccess<'de>,
9640 {
9641 let mut source_id__ = None;
9642 let mut cascade__ = None;
9643 while let Some(k) = map_.next_key()? {
9644 match k {
9645 GeneratedField::SourceId => {
9646 if source_id__.is_some() {
9647 return Err(serde::de::Error::duplicate_field("sourceId"));
9648 }
9649 source_id__ =
9650 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9651 ;
9652 }
9653 GeneratedField::Cascade => {
9654 if cascade__.is_some() {
9655 return Err(serde::de::Error::duplicate_field("cascade"));
9656 }
9657 cascade__ = Some(map_.next_value()?);
9658 }
9659 }
9660 }
9661 Ok(DropSourceRequest {
9662 source_id: source_id__.unwrap_or_default(),
9663 cascade: cascade__.unwrap_or_default(),
9664 })
9665 }
9666 }
9667 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
9668 }
9669}
9670impl serde::Serialize for DropSourceResponse {
9671 #[allow(deprecated)]
9672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9673 where
9674 S: serde::Serializer,
9675 {
9676 use serde::ser::SerializeStruct;
9677 let mut len = 0;
9678 if self.status.is_some() {
9679 len += 1;
9680 }
9681 if self.version.is_some() {
9682 len += 1;
9683 }
9684 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
9685 if let Some(v) = self.status.as_ref() {
9686 struct_ser.serialize_field("status", v)?;
9687 }
9688 if let Some(v) = self.version.as_ref() {
9689 struct_ser.serialize_field("version", v)?;
9690 }
9691 struct_ser.end()
9692 }
9693}
9694impl<'de> serde::Deserialize<'de> for DropSourceResponse {
9695 #[allow(deprecated)]
9696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9697 where
9698 D: serde::Deserializer<'de>,
9699 {
9700 const FIELDS: &[&str] = &[
9701 "status",
9702 "version",
9703 ];
9704
9705 #[allow(clippy::enum_variant_names)]
9706 enum GeneratedField {
9707 Status,
9708 Version,
9709 }
9710 impl<'de> serde::Deserialize<'de> for GeneratedField {
9711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9712 where
9713 D: serde::Deserializer<'de>,
9714 {
9715 struct GeneratedVisitor;
9716
9717 impl serde::de::Visitor<'_> for GeneratedVisitor {
9718 type Value = GeneratedField;
9719
9720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9721 write!(formatter, "expected one of: {:?}", &FIELDS)
9722 }
9723
9724 #[allow(unused_variables)]
9725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9726 where
9727 E: serde::de::Error,
9728 {
9729 match value {
9730 "status" => Ok(GeneratedField::Status),
9731 "version" => Ok(GeneratedField::Version),
9732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9733 }
9734 }
9735 }
9736 deserializer.deserialize_identifier(GeneratedVisitor)
9737 }
9738 }
9739 struct GeneratedVisitor;
9740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9741 type Value = DropSourceResponse;
9742
9743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9744 formatter.write_str("struct ddl_service.DropSourceResponse")
9745 }
9746
9747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9748 where
9749 V: serde::de::MapAccess<'de>,
9750 {
9751 let mut status__ = None;
9752 let mut version__ = None;
9753 while let Some(k) = map_.next_key()? {
9754 match k {
9755 GeneratedField::Status => {
9756 if status__.is_some() {
9757 return Err(serde::de::Error::duplicate_field("status"));
9758 }
9759 status__ = map_.next_value()?;
9760 }
9761 GeneratedField::Version => {
9762 if version__.is_some() {
9763 return Err(serde::de::Error::duplicate_field("version"));
9764 }
9765 version__ = map_.next_value()?;
9766 }
9767 }
9768 }
9769 Ok(DropSourceResponse {
9770 status: status__,
9771 version: version__,
9772 })
9773 }
9774 }
9775 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9776 }
9777}
9778impl serde::Serialize for DropSubscriptionRequest {
9779 #[allow(deprecated)]
9780 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9781 where
9782 S: serde::Serializer,
9783 {
9784 use serde::ser::SerializeStruct;
9785 let mut len = 0;
9786 if self.subscription_id != 0 {
9787 len += 1;
9788 }
9789 if self.cascade {
9790 len += 1;
9791 }
9792 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9793 if self.subscription_id != 0 {
9794 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9795 }
9796 if self.cascade {
9797 struct_ser.serialize_field("cascade", &self.cascade)?;
9798 }
9799 struct_ser.end()
9800 }
9801}
9802impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9803 #[allow(deprecated)]
9804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9805 where
9806 D: serde::Deserializer<'de>,
9807 {
9808 const FIELDS: &[&str] = &[
9809 "subscription_id",
9810 "subscriptionId",
9811 "cascade",
9812 ];
9813
9814 #[allow(clippy::enum_variant_names)]
9815 enum GeneratedField {
9816 SubscriptionId,
9817 Cascade,
9818 }
9819 impl<'de> serde::Deserialize<'de> for GeneratedField {
9820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9821 where
9822 D: serde::Deserializer<'de>,
9823 {
9824 struct GeneratedVisitor;
9825
9826 impl serde::de::Visitor<'_> for GeneratedVisitor {
9827 type Value = GeneratedField;
9828
9829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9830 write!(formatter, "expected one of: {:?}", &FIELDS)
9831 }
9832
9833 #[allow(unused_variables)]
9834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9835 where
9836 E: serde::de::Error,
9837 {
9838 match value {
9839 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9840 "cascade" => Ok(GeneratedField::Cascade),
9841 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9842 }
9843 }
9844 }
9845 deserializer.deserialize_identifier(GeneratedVisitor)
9846 }
9847 }
9848 struct GeneratedVisitor;
9849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9850 type Value = DropSubscriptionRequest;
9851
9852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9853 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9854 }
9855
9856 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9857 where
9858 V: serde::de::MapAccess<'de>,
9859 {
9860 let mut subscription_id__ = None;
9861 let mut cascade__ = None;
9862 while let Some(k) = map_.next_key()? {
9863 match k {
9864 GeneratedField::SubscriptionId => {
9865 if subscription_id__.is_some() {
9866 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9867 }
9868 subscription_id__ =
9869 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9870 ;
9871 }
9872 GeneratedField::Cascade => {
9873 if cascade__.is_some() {
9874 return Err(serde::de::Error::duplicate_field("cascade"));
9875 }
9876 cascade__ = Some(map_.next_value()?);
9877 }
9878 }
9879 }
9880 Ok(DropSubscriptionRequest {
9881 subscription_id: subscription_id__.unwrap_or_default(),
9882 cascade: cascade__.unwrap_or_default(),
9883 })
9884 }
9885 }
9886 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9887 }
9888}
9889impl serde::Serialize for DropSubscriptionResponse {
9890 #[allow(deprecated)]
9891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9892 where
9893 S: serde::Serializer,
9894 {
9895 use serde::ser::SerializeStruct;
9896 let mut len = 0;
9897 if self.status.is_some() {
9898 len += 1;
9899 }
9900 if self.version.is_some() {
9901 len += 1;
9902 }
9903 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9904 if let Some(v) = self.status.as_ref() {
9905 struct_ser.serialize_field("status", v)?;
9906 }
9907 if let Some(v) = self.version.as_ref() {
9908 struct_ser.serialize_field("version", v)?;
9909 }
9910 struct_ser.end()
9911 }
9912}
9913impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9914 #[allow(deprecated)]
9915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9916 where
9917 D: serde::Deserializer<'de>,
9918 {
9919 const FIELDS: &[&str] = &[
9920 "status",
9921 "version",
9922 ];
9923
9924 #[allow(clippy::enum_variant_names)]
9925 enum GeneratedField {
9926 Status,
9927 Version,
9928 }
9929 impl<'de> serde::Deserialize<'de> for GeneratedField {
9930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9931 where
9932 D: serde::Deserializer<'de>,
9933 {
9934 struct GeneratedVisitor;
9935
9936 impl serde::de::Visitor<'_> for GeneratedVisitor {
9937 type Value = GeneratedField;
9938
9939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9940 write!(formatter, "expected one of: {:?}", &FIELDS)
9941 }
9942
9943 #[allow(unused_variables)]
9944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9945 where
9946 E: serde::de::Error,
9947 {
9948 match value {
9949 "status" => Ok(GeneratedField::Status),
9950 "version" => Ok(GeneratedField::Version),
9951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9952 }
9953 }
9954 }
9955 deserializer.deserialize_identifier(GeneratedVisitor)
9956 }
9957 }
9958 struct GeneratedVisitor;
9959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9960 type Value = DropSubscriptionResponse;
9961
9962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9963 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
9964 }
9965
9966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
9967 where
9968 V: serde::de::MapAccess<'de>,
9969 {
9970 let mut status__ = None;
9971 let mut version__ = None;
9972 while let Some(k) = map_.next_key()? {
9973 match k {
9974 GeneratedField::Status => {
9975 if status__.is_some() {
9976 return Err(serde::de::Error::duplicate_field("status"));
9977 }
9978 status__ = map_.next_value()?;
9979 }
9980 GeneratedField::Version => {
9981 if version__.is_some() {
9982 return Err(serde::de::Error::duplicate_field("version"));
9983 }
9984 version__ = map_.next_value()?;
9985 }
9986 }
9987 }
9988 Ok(DropSubscriptionResponse {
9989 status: status__,
9990 version: version__,
9991 })
9992 }
9993 }
9994 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
9995 }
9996}
9997impl serde::Serialize for DropTableRequest {
9998 #[allow(deprecated)]
9999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10000 where
10001 S: serde::Serializer,
10002 {
10003 use serde::ser::SerializeStruct;
10004 let mut len = 0;
10005 if self.table_id != 0 {
10006 len += 1;
10007 }
10008 if self.cascade {
10009 len += 1;
10010 }
10011 if self.source_id.is_some() {
10012 len += 1;
10013 }
10014 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
10015 if self.table_id != 0 {
10016 struct_ser.serialize_field("tableId", &self.table_id)?;
10017 }
10018 if self.cascade {
10019 struct_ser.serialize_field("cascade", &self.cascade)?;
10020 }
10021 if let Some(v) = self.source_id.as_ref() {
10022 match v {
10023 drop_table_request::SourceId::Id(v) => {
10024 struct_ser.serialize_field("id", v)?;
10025 }
10026 }
10027 }
10028 struct_ser.end()
10029 }
10030}
10031impl<'de> serde::Deserialize<'de> for DropTableRequest {
10032 #[allow(deprecated)]
10033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10034 where
10035 D: serde::Deserializer<'de>,
10036 {
10037 const FIELDS: &[&str] = &[
10038 "table_id",
10039 "tableId",
10040 "cascade",
10041 "id",
10042 ];
10043
10044 #[allow(clippy::enum_variant_names)]
10045 enum GeneratedField {
10046 TableId,
10047 Cascade,
10048 Id,
10049 }
10050 impl<'de> serde::Deserialize<'de> for GeneratedField {
10051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10052 where
10053 D: serde::Deserializer<'de>,
10054 {
10055 struct GeneratedVisitor;
10056
10057 impl serde::de::Visitor<'_> for GeneratedVisitor {
10058 type Value = GeneratedField;
10059
10060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10061 write!(formatter, "expected one of: {:?}", &FIELDS)
10062 }
10063
10064 #[allow(unused_variables)]
10065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10066 where
10067 E: serde::de::Error,
10068 {
10069 match value {
10070 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10071 "cascade" => Ok(GeneratedField::Cascade),
10072 "id" => Ok(GeneratedField::Id),
10073 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10074 }
10075 }
10076 }
10077 deserializer.deserialize_identifier(GeneratedVisitor)
10078 }
10079 }
10080 struct GeneratedVisitor;
10081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10082 type Value = DropTableRequest;
10083
10084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10085 formatter.write_str("struct ddl_service.DropTableRequest")
10086 }
10087
10088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
10089 where
10090 V: serde::de::MapAccess<'de>,
10091 {
10092 let mut table_id__ = None;
10093 let mut cascade__ = None;
10094 let mut source_id__ = None;
10095 while let Some(k) = map_.next_key()? {
10096 match k {
10097 GeneratedField::TableId => {
10098 if table_id__.is_some() {
10099 return Err(serde::de::Error::duplicate_field("tableId"));
10100 }
10101 table_id__ =
10102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10103 ;
10104 }
10105 GeneratedField::Cascade => {
10106 if cascade__.is_some() {
10107 return Err(serde::de::Error::duplicate_field("cascade"));
10108 }
10109 cascade__ = Some(map_.next_value()?);
10110 }
10111 GeneratedField::Id => {
10112 if source_id__.is_some() {
10113 return Err(serde::de::Error::duplicate_field("id"));
10114 }
10115 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
10116 }
10117 }
10118 }
10119 Ok(DropTableRequest {
10120 table_id: table_id__.unwrap_or_default(),
10121 cascade: cascade__.unwrap_or_default(),
10122 source_id: source_id__,
10123 })
10124 }
10125 }
10126 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
10127 }
10128}
10129impl serde::Serialize for DropTableResponse {
10130 #[allow(deprecated)]
10131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10132 where
10133 S: serde::Serializer,
10134 {
10135 use serde::ser::SerializeStruct;
10136 let mut len = 0;
10137 if self.status.is_some() {
10138 len += 1;
10139 }
10140 if self.version.is_some() {
10141 len += 1;
10142 }
10143 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
10144 if let Some(v) = self.status.as_ref() {
10145 struct_ser.serialize_field("status", v)?;
10146 }
10147 if let Some(v) = self.version.as_ref() {
10148 struct_ser.serialize_field("version", v)?;
10149 }
10150 struct_ser.end()
10151 }
10152}
10153impl<'de> serde::Deserialize<'de> for DropTableResponse {
10154 #[allow(deprecated)]
10155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10156 where
10157 D: serde::Deserializer<'de>,
10158 {
10159 const FIELDS: &[&str] = &[
10160 "status",
10161 "version",
10162 ];
10163
10164 #[allow(clippy::enum_variant_names)]
10165 enum GeneratedField {
10166 Status,
10167 Version,
10168 }
10169 impl<'de> serde::Deserialize<'de> for GeneratedField {
10170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10171 where
10172 D: serde::Deserializer<'de>,
10173 {
10174 struct GeneratedVisitor;
10175
10176 impl serde::de::Visitor<'_> for GeneratedVisitor {
10177 type Value = GeneratedField;
10178
10179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10180 write!(formatter, "expected one of: {:?}", &FIELDS)
10181 }
10182
10183 #[allow(unused_variables)]
10184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10185 where
10186 E: serde::de::Error,
10187 {
10188 match value {
10189 "status" => Ok(GeneratedField::Status),
10190 "version" => Ok(GeneratedField::Version),
10191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10192 }
10193 }
10194 }
10195 deserializer.deserialize_identifier(GeneratedVisitor)
10196 }
10197 }
10198 struct GeneratedVisitor;
10199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10200 type Value = DropTableResponse;
10201
10202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10203 formatter.write_str("struct ddl_service.DropTableResponse")
10204 }
10205
10206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
10207 where
10208 V: serde::de::MapAccess<'de>,
10209 {
10210 let mut status__ = None;
10211 let mut version__ = None;
10212 while let Some(k) = map_.next_key()? {
10213 match k {
10214 GeneratedField::Status => {
10215 if status__.is_some() {
10216 return Err(serde::de::Error::duplicate_field("status"));
10217 }
10218 status__ = map_.next_value()?;
10219 }
10220 GeneratedField::Version => {
10221 if version__.is_some() {
10222 return Err(serde::de::Error::duplicate_field("version"));
10223 }
10224 version__ = map_.next_value()?;
10225 }
10226 }
10227 }
10228 Ok(DropTableResponse {
10229 status: status__,
10230 version: version__,
10231 })
10232 }
10233 }
10234 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
10235 }
10236}
10237impl serde::Serialize for DropViewRequest {
10238 #[allow(deprecated)]
10239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10240 where
10241 S: serde::Serializer,
10242 {
10243 use serde::ser::SerializeStruct;
10244 let mut len = 0;
10245 if self.view_id != 0 {
10246 len += 1;
10247 }
10248 if self.cascade {
10249 len += 1;
10250 }
10251 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
10252 if self.view_id != 0 {
10253 struct_ser.serialize_field("viewId", &self.view_id)?;
10254 }
10255 if self.cascade {
10256 struct_ser.serialize_field("cascade", &self.cascade)?;
10257 }
10258 struct_ser.end()
10259 }
10260}
10261impl<'de> serde::Deserialize<'de> for DropViewRequest {
10262 #[allow(deprecated)]
10263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10264 where
10265 D: serde::Deserializer<'de>,
10266 {
10267 const FIELDS: &[&str] = &[
10268 "view_id",
10269 "viewId",
10270 "cascade",
10271 ];
10272
10273 #[allow(clippy::enum_variant_names)]
10274 enum GeneratedField {
10275 ViewId,
10276 Cascade,
10277 }
10278 impl<'de> serde::Deserialize<'de> for GeneratedField {
10279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10280 where
10281 D: serde::Deserializer<'de>,
10282 {
10283 struct GeneratedVisitor;
10284
10285 impl serde::de::Visitor<'_> for GeneratedVisitor {
10286 type Value = GeneratedField;
10287
10288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10289 write!(formatter, "expected one of: {:?}", &FIELDS)
10290 }
10291
10292 #[allow(unused_variables)]
10293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10294 where
10295 E: serde::de::Error,
10296 {
10297 match value {
10298 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
10299 "cascade" => Ok(GeneratedField::Cascade),
10300 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10301 }
10302 }
10303 }
10304 deserializer.deserialize_identifier(GeneratedVisitor)
10305 }
10306 }
10307 struct GeneratedVisitor;
10308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10309 type Value = DropViewRequest;
10310
10311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10312 formatter.write_str("struct ddl_service.DropViewRequest")
10313 }
10314
10315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
10316 where
10317 V: serde::de::MapAccess<'de>,
10318 {
10319 let mut view_id__ = None;
10320 let mut cascade__ = None;
10321 while let Some(k) = map_.next_key()? {
10322 match k {
10323 GeneratedField::ViewId => {
10324 if view_id__.is_some() {
10325 return Err(serde::de::Error::duplicate_field("viewId"));
10326 }
10327 view_id__ =
10328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10329 ;
10330 }
10331 GeneratedField::Cascade => {
10332 if cascade__.is_some() {
10333 return Err(serde::de::Error::duplicate_field("cascade"));
10334 }
10335 cascade__ = Some(map_.next_value()?);
10336 }
10337 }
10338 }
10339 Ok(DropViewRequest {
10340 view_id: view_id__.unwrap_or_default(),
10341 cascade: cascade__.unwrap_or_default(),
10342 })
10343 }
10344 }
10345 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
10346 }
10347}
10348impl serde::Serialize for DropViewResponse {
10349 #[allow(deprecated)]
10350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10351 where
10352 S: serde::Serializer,
10353 {
10354 use serde::ser::SerializeStruct;
10355 let mut len = 0;
10356 if self.status.is_some() {
10357 len += 1;
10358 }
10359 if self.version.is_some() {
10360 len += 1;
10361 }
10362 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
10363 if let Some(v) = self.status.as_ref() {
10364 struct_ser.serialize_field("status", v)?;
10365 }
10366 if let Some(v) = self.version.as_ref() {
10367 struct_ser.serialize_field("version", v)?;
10368 }
10369 struct_ser.end()
10370 }
10371}
10372impl<'de> serde::Deserialize<'de> for DropViewResponse {
10373 #[allow(deprecated)]
10374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10375 where
10376 D: serde::Deserializer<'de>,
10377 {
10378 const FIELDS: &[&str] = &[
10379 "status",
10380 "version",
10381 ];
10382
10383 #[allow(clippy::enum_variant_names)]
10384 enum GeneratedField {
10385 Status,
10386 Version,
10387 }
10388 impl<'de> serde::Deserialize<'de> for GeneratedField {
10389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10390 where
10391 D: serde::Deserializer<'de>,
10392 {
10393 struct GeneratedVisitor;
10394
10395 impl serde::de::Visitor<'_> for GeneratedVisitor {
10396 type Value = GeneratedField;
10397
10398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10399 write!(formatter, "expected one of: {:?}", &FIELDS)
10400 }
10401
10402 #[allow(unused_variables)]
10403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10404 where
10405 E: serde::de::Error,
10406 {
10407 match value {
10408 "status" => Ok(GeneratedField::Status),
10409 "version" => Ok(GeneratedField::Version),
10410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10411 }
10412 }
10413 }
10414 deserializer.deserialize_identifier(GeneratedVisitor)
10415 }
10416 }
10417 struct GeneratedVisitor;
10418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10419 type Value = DropViewResponse;
10420
10421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10422 formatter.write_str("struct ddl_service.DropViewResponse")
10423 }
10424
10425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
10426 where
10427 V: serde::de::MapAccess<'de>,
10428 {
10429 let mut status__ = None;
10430 let mut version__ = None;
10431 while let Some(k) = map_.next_key()? {
10432 match k {
10433 GeneratedField::Status => {
10434 if status__.is_some() {
10435 return Err(serde::de::Error::duplicate_field("status"));
10436 }
10437 status__ = map_.next_value()?;
10438 }
10439 GeneratedField::Version => {
10440 if version__.is_some() {
10441 return Err(serde::de::Error::duplicate_field("version"));
10442 }
10443 version__ = map_.next_value()?;
10444 }
10445 }
10446 }
10447 Ok(DropViewResponse {
10448 status: status__,
10449 version: version__,
10450 })
10451 }
10452 }
10453 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
10454 }
10455}
10456impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
10457 #[allow(deprecated)]
10458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10459 where
10460 S: serde::Serializer,
10461 {
10462 use serde::ser::SerializeStruct;
10463 let mut len = 0;
10464 if self.sink_id != 0 {
10465 len += 1;
10466 }
10467 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
10468 if self.sink_id != 0 {
10469 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10470 }
10471 struct_ser.end()
10472 }
10473}
10474impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10475 #[allow(deprecated)]
10476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10477 where
10478 D: serde::Deserializer<'de>,
10479 {
10480 const FIELDS: &[&str] = &[
10481 "sink_id",
10482 "sinkId",
10483 ];
10484
10485 #[allow(clippy::enum_variant_names)]
10486 enum GeneratedField {
10487 SinkId,
10488 }
10489 impl<'de> serde::Deserialize<'de> for GeneratedField {
10490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10491 where
10492 D: serde::Deserializer<'de>,
10493 {
10494 struct GeneratedVisitor;
10495
10496 impl serde::de::Visitor<'_> for GeneratedVisitor {
10497 type Value = GeneratedField;
10498
10499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10500 write!(formatter, "expected one of: {:?}", &FIELDS)
10501 }
10502
10503 #[allow(unused_variables)]
10504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10505 where
10506 E: serde::de::Error,
10507 {
10508 match value {
10509 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10510 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10511 }
10512 }
10513 }
10514 deserializer.deserialize_identifier(GeneratedVisitor)
10515 }
10516 }
10517 struct GeneratedVisitor;
10518 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10519 type Value = ExpireIcebergTableSnapshotsRequest;
10520
10521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10522 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10523 }
10524
10525 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10526 where
10527 V: serde::de::MapAccess<'de>,
10528 {
10529 let mut sink_id__ = None;
10530 while let Some(k) = map_.next_key()? {
10531 match k {
10532 GeneratedField::SinkId => {
10533 if sink_id__.is_some() {
10534 return Err(serde::de::Error::duplicate_field("sinkId"));
10535 }
10536 sink_id__ =
10537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10538 ;
10539 }
10540 }
10541 }
10542 Ok(ExpireIcebergTableSnapshotsRequest {
10543 sink_id: sink_id__.unwrap_or_default(),
10544 })
10545 }
10546 }
10547 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10548 }
10549}
10550impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10551 #[allow(deprecated)]
10552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10553 where
10554 S: serde::Serializer,
10555 {
10556 use serde::ser::SerializeStruct;
10557 let mut len = 0;
10558 if self.status.is_some() {
10559 len += 1;
10560 }
10561 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10562 if let Some(v) = self.status.as_ref() {
10563 struct_ser.serialize_field("status", v)?;
10564 }
10565 struct_ser.end()
10566 }
10567}
10568impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10569 #[allow(deprecated)]
10570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10571 where
10572 D: serde::Deserializer<'de>,
10573 {
10574 const FIELDS: &[&str] = &[
10575 "status",
10576 ];
10577
10578 #[allow(clippy::enum_variant_names)]
10579 enum GeneratedField {
10580 Status,
10581 }
10582 impl<'de> serde::Deserialize<'de> for GeneratedField {
10583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10584 where
10585 D: serde::Deserializer<'de>,
10586 {
10587 struct GeneratedVisitor;
10588
10589 impl serde::de::Visitor<'_> for GeneratedVisitor {
10590 type Value = GeneratedField;
10591
10592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10593 write!(formatter, "expected one of: {:?}", &FIELDS)
10594 }
10595
10596 #[allow(unused_variables)]
10597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10598 where
10599 E: serde::de::Error,
10600 {
10601 match value {
10602 "status" => Ok(GeneratedField::Status),
10603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10604 }
10605 }
10606 }
10607 deserializer.deserialize_identifier(GeneratedVisitor)
10608 }
10609 }
10610 struct GeneratedVisitor;
10611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10612 type Value = ExpireIcebergTableSnapshotsResponse;
10613
10614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10615 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10616 }
10617
10618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10619 where
10620 V: serde::de::MapAccess<'de>,
10621 {
10622 let mut status__ = None;
10623 while let Some(k) = map_.next_key()? {
10624 match k {
10625 GeneratedField::Status => {
10626 if status__.is_some() {
10627 return Err(serde::de::Error::duplicate_field("status"));
10628 }
10629 status__ = map_.next_value()?;
10630 }
10631 }
10632 }
10633 Ok(ExpireIcebergTableSnapshotsResponse {
10634 status: status__,
10635 })
10636 }
10637 }
10638 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10639 }
10640}
10641impl serde::Serialize for GetDdlProgressRequest {
10642 #[allow(deprecated)]
10643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10644 where
10645 S: serde::Serializer,
10646 {
10647 use serde::ser::SerializeStruct;
10648 let len = 0;
10649 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10650 struct_ser.end()
10651 }
10652}
10653impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10654 #[allow(deprecated)]
10655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10656 where
10657 D: serde::Deserializer<'de>,
10658 {
10659 const FIELDS: &[&str] = &[
10660 ];
10661
10662 #[allow(clippy::enum_variant_names)]
10663 enum GeneratedField {
10664 }
10665 impl<'de> serde::Deserialize<'de> for GeneratedField {
10666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10667 where
10668 D: serde::Deserializer<'de>,
10669 {
10670 struct GeneratedVisitor;
10671
10672 impl serde::de::Visitor<'_> for GeneratedVisitor {
10673 type Value = GeneratedField;
10674
10675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10676 write!(formatter, "expected one of: {:?}", &FIELDS)
10677 }
10678
10679 #[allow(unused_variables)]
10680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10681 where
10682 E: serde::de::Error,
10683 {
10684 Err(serde::de::Error::unknown_field(value, FIELDS))
10685 }
10686 }
10687 deserializer.deserialize_identifier(GeneratedVisitor)
10688 }
10689 }
10690 struct GeneratedVisitor;
10691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10692 type Value = GetDdlProgressRequest;
10693
10694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10695 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
10696 }
10697
10698 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
10699 where
10700 V: serde::de::MapAccess<'de>,
10701 {
10702 while map_.next_key::<GeneratedField>()?.is_some() {
10703 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10704 }
10705 Ok(GetDdlProgressRequest {
10706 })
10707 }
10708 }
10709 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
10710 }
10711}
10712impl serde::Serialize for GetDdlProgressResponse {
10713 #[allow(deprecated)]
10714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10715 where
10716 S: serde::Serializer,
10717 {
10718 use serde::ser::SerializeStruct;
10719 let mut len = 0;
10720 if !self.ddl_progress.is_empty() {
10721 len += 1;
10722 }
10723 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
10724 if !self.ddl_progress.is_empty() {
10725 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
10726 }
10727 struct_ser.end()
10728 }
10729}
10730impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
10731 #[allow(deprecated)]
10732 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10733 where
10734 D: serde::Deserializer<'de>,
10735 {
10736 const FIELDS: &[&str] = &[
10737 "ddl_progress",
10738 "ddlProgress",
10739 ];
10740
10741 #[allow(clippy::enum_variant_names)]
10742 enum GeneratedField {
10743 DdlProgress,
10744 }
10745 impl<'de> serde::Deserialize<'de> for GeneratedField {
10746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10747 where
10748 D: serde::Deserializer<'de>,
10749 {
10750 struct GeneratedVisitor;
10751
10752 impl serde::de::Visitor<'_> for GeneratedVisitor {
10753 type Value = GeneratedField;
10754
10755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10756 write!(formatter, "expected one of: {:?}", &FIELDS)
10757 }
10758
10759 #[allow(unused_variables)]
10760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10761 where
10762 E: serde::de::Error,
10763 {
10764 match value {
10765 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10767 }
10768 }
10769 }
10770 deserializer.deserialize_identifier(GeneratedVisitor)
10771 }
10772 }
10773 struct GeneratedVisitor;
10774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10775 type Value = GetDdlProgressResponse;
10776
10777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10778 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10779 }
10780
10781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10782 where
10783 V: serde::de::MapAccess<'de>,
10784 {
10785 let mut ddl_progress__ = None;
10786 while let Some(k) = map_.next_key()? {
10787 match k {
10788 GeneratedField::DdlProgress => {
10789 if ddl_progress__.is_some() {
10790 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10791 }
10792 ddl_progress__ = Some(map_.next_value()?);
10793 }
10794 }
10795 }
10796 Ok(GetDdlProgressResponse {
10797 ddl_progress: ddl_progress__.unwrap_or_default(),
10798 })
10799 }
10800 }
10801 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10802 }
10803}
10804impl serde::Serialize for GetTableRequest {
10805 #[allow(deprecated)]
10806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10807 where
10808 S: serde::Serializer,
10809 {
10810 use serde::ser::SerializeStruct;
10811 let mut len = 0;
10812 if !self.database_name.is_empty() {
10813 len += 1;
10814 }
10815 if !self.table_name.is_empty() {
10816 len += 1;
10817 }
10818 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10819 if !self.database_name.is_empty() {
10820 struct_ser.serialize_field("databaseName", &self.database_name)?;
10821 }
10822 if !self.table_name.is_empty() {
10823 struct_ser.serialize_field("tableName", &self.table_name)?;
10824 }
10825 struct_ser.end()
10826 }
10827}
10828impl<'de> serde::Deserialize<'de> for GetTableRequest {
10829 #[allow(deprecated)]
10830 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10831 where
10832 D: serde::Deserializer<'de>,
10833 {
10834 const FIELDS: &[&str] = &[
10835 "database_name",
10836 "databaseName",
10837 "table_name",
10838 "tableName",
10839 ];
10840
10841 #[allow(clippy::enum_variant_names)]
10842 enum GeneratedField {
10843 DatabaseName,
10844 TableName,
10845 }
10846 impl<'de> serde::Deserialize<'de> for GeneratedField {
10847 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10848 where
10849 D: serde::Deserializer<'de>,
10850 {
10851 struct GeneratedVisitor;
10852
10853 impl serde::de::Visitor<'_> for GeneratedVisitor {
10854 type Value = GeneratedField;
10855
10856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10857 write!(formatter, "expected one of: {:?}", &FIELDS)
10858 }
10859
10860 #[allow(unused_variables)]
10861 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10862 where
10863 E: serde::de::Error,
10864 {
10865 match value {
10866 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10867 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10868 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10869 }
10870 }
10871 }
10872 deserializer.deserialize_identifier(GeneratedVisitor)
10873 }
10874 }
10875 struct GeneratedVisitor;
10876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10877 type Value = GetTableRequest;
10878
10879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10880 formatter.write_str("struct ddl_service.GetTableRequest")
10881 }
10882
10883 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10884 where
10885 V: serde::de::MapAccess<'de>,
10886 {
10887 let mut database_name__ = None;
10888 let mut table_name__ = None;
10889 while let Some(k) = map_.next_key()? {
10890 match k {
10891 GeneratedField::DatabaseName => {
10892 if database_name__.is_some() {
10893 return Err(serde::de::Error::duplicate_field("databaseName"));
10894 }
10895 database_name__ = Some(map_.next_value()?);
10896 }
10897 GeneratedField::TableName => {
10898 if table_name__.is_some() {
10899 return Err(serde::de::Error::duplicate_field("tableName"));
10900 }
10901 table_name__ = Some(map_.next_value()?);
10902 }
10903 }
10904 }
10905 Ok(GetTableRequest {
10906 database_name: database_name__.unwrap_or_default(),
10907 table_name: table_name__.unwrap_or_default(),
10908 })
10909 }
10910 }
10911 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10912 }
10913}
10914impl serde::Serialize for GetTableResponse {
10915 #[allow(deprecated)]
10916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10917 where
10918 S: serde::Serializer,
10919 {
10920 use serde::ser::SerializeStruct;
10921 let mut len = 0;
10922 if self.table.is_some() {
10923 len += 1;
10924 }
10925 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10926 if let Some(v) = self.table.as_ref() {
10927 struct_ser.serialize_field("table", v)?;
10928 }
10929 struct_ser.end()
10930 }
10931}
10932impl<'de> serde::Deserialize<'de> for GetTableResponse {
10933 #[allow(deprecated)]
10934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10935 where
10936 D: serde::Deserializer<'de>,
10937 {
10938 const FIELDS: &[&str] = &[
10939 "table",
10940 ];
10941
10942 #[allow(clippy::enum_variant_names)]
10943 enum GeneratedField {
10944 Table,
10945 }
10946 impl<'de> serde::Deserialize<'de> for GeneratedField {
10947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10948 where
10949 D: serde::Deserializer<'de>,
10950 {
10951 struct GeneratedVisitor;
10952
10953 impl serde::de::Visitor<'_> for GeneratedVisitor {
10954 type Value = GeneratedField;
10955
10956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10957 write!(formatter, "expected one of: {:?}", &FIELDS)
10958 }
10959
10960 #[allow(unused_variables)]
10961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10962 where
10963 E: serde::de::Error,
10964 {
10965 match value {
10966 "table" => Ok(GeneratedField::Table),
10967 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10968 }
10969 }
10970 }
10971 deserializer.deserialize_identifier(GeneratedVisitor)
10972 }
10973 }
10974 struct GeneratedVisitor;
10975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10976 type Value = GetTableResponse;
10977
10978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10979 formatter.write_str("struct ddl_service.GetTableResponse")
10980 }
10981
10982 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
10983 where
10984 V: serde::de::MapAccess<'de>,
10985 {
10986 let mut table__ = None;
10987 while let Some(k) = map_.next_key()? {
10988 match k {
10989 GeneratedField::Table => {
10990 if table__.is_some() {
10991 return Err(serde::de::Error::duplicate_field("table"));
10992 }
10993 table__ = map_.next_value()?;
10994 }
10995 }
10996 }
10997 Ok(GetTableResponse {
10998 table: table__,
10999 })
11000 }
11001 }
11002 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
11003 }
11004}
11005impl serde::Serialize for GetTablesRequest {
11006 #[allow(deprecated)]
11007 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11008 where
11009 S: serde::Serializer,
11010 {
11011 use serde::ser::SerializeStruct;
11012 let mut len = 0;
11013 if !self.table_ids.is_empty() {
11014 len += 1;
11015 }
11016 if self.include_dropped_tables {
11017 len += 1;
11018 }
11019 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
11020 if !self.table_ids.is_empty() {
11021 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11022 }
11023 if self.include_dropped_tables {
11024 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
11025 }
11026 struct_ser.end()
11027 }
11028}
11029impl<'de> serde::Deserialize<'de> for GetTablesRequest {
11030 #[allow(deprecated)]
11031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11032 where
11033 D: serde::Deserializer<'de>,
11034 {
11035 const FIELDS: &[&str] = &[
11036 "table_ids",
11037 "tableIds",
11038 "include_dropped_tables",
11039 "includeDroppedTables",
11040 ];
11041
11042 #[allow(clippy::enum_variant_names)]
11043 enum GeneratedField {
11044 TableIds,
11045 IncludeDroppedTables,
11046 }
11047 impl<'de> serde::Deserialize<'de> for GeneratedField {
11048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11049 where
11050 D: serde::Deserializer<'de>,
11051 {
11052 struct GeneratedVisitor;
11053
11054 impl serde::de::Visitor<'_> for GeneratedVisitor {
11055 type Value = GeneratedField;
11056
11057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11058 write!(formatter, "expected one of: {:?}", &FIELDS)
11059 }
11060
11061 #[allow(unused_variables)]
11062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11063 where
11064 E: serde::de::Error,
11065 {
11066 match value {
11067 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11068 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
11069 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11070 }
11071 }
11072 }
11073 deserializer.deserialize_identifier(GeneratedVisitor)
11074 }
11075 }
11076 struct GeneratedVisitor;
11077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11078 type Value = GetTablesRequest;
11079
11080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11081 formatter.write_str("struct ddl_service.GetTablesRequest")
11082 }
11083
11084 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
11085 where
11086 V: serde::de::MapAccess<'de>,
11087 {
11088 let mut table_ids__ = None;
11089 let mut include_dropped_tables__ = None;
11090 while let Some(k) = map_.next_key()? {
11091 match k {
11092 GeneratedField::TableIds => {
11093 if table_ids__.is_some() {
11094 return Err(serde::de::Error::duplicate_field("tableIds"));
11095 }
11096 table_ids__ =
11097 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11098 .into_iter().map(|x| x.0).collect())
11099 ;
11100 }
11101 GeneratedField::IncludeDroppedTables => {
11102 if include_dropped_tables__.is_some() {
11103 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
11104 }
11105 include_dropped_tables__ = Some(map_.next_value()?);
11106 }
11107 }
11108 }
11109 Ok(GetTablesRequest {
11110 table_ids: table_ids__.unwrap_or_default(),
11111 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
11112 })
11113 }
11114 }
11115 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
11116 }
11117}
11118impl serde::Serialize for GetTablesResponse {
11119 #[allow(deprecated)]
11120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11121 where
11122 S: serde::Serializer,
11123 {
11124 use serde::ser::SerializeStruct;
11125 let mut len = 0;
11126 if !self.tables.is_empty() {
11127 len += 1;
11128 }
11129 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
11130 if !self.tables.is_empty() {
11131 struct_ser.serialize_field("tables", &self.tables)?;
11132 }
11133 struct_ser.end()
11134 }
11135}
11136impl<'de> serde::Deserialize<'de> for GetTablesResponse {
11137 #[allow(deprecated)]
11138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11139 where
11140 D: serde::Deserializer<'de>,
11141 {
11142 const FIELDS: &[&str] = &[
11143 "tables",
11144 ];
11145
11146 #[allow(clippy::enum_variant_names)]
11147 enum GeneratedField {
11148 Tables,
11149 }
11150 impl<'de> serde::Deserialize<'de> for GeneratedField {
11151 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11152 where
11153 D: serde::Deserializer<'de>,
11154 {
11155 struct GeneratedVisitor;
11156
11157 impl serde::de::Visitor<'_> for GeneratedVisitor {
11158 type Value = GeneratedField;
11159
11160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11161 write!(formatter, "expected one of: {:?}", &FIELDS)
11162 }
11163
11164 #[allow(unused_variables)]
11165 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11166 where
11167 E: serde::de::Error,
11168 {
11169 match value {
11170 "tables" => Ok(GeneratedField::Tables),
11171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11172 }
11173 }
11174 }
11175 deserializer.deserialize_identifier(GeneratedVisitor)
11176 }
11177 }
11178 struct GeneratedVisitor;
11179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11180 type Value = GetTablesResponse;
11181
11182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11183 formatter.write_str("struct ddl_service.GetTablesResponse")
11184 }
11185
11186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
11187 where
11188 V: serde::de::MapAccess<'de>,
11189 {
11190 let mut tables__ = None;
11191 while let Some(k) = map_.next_key()? {
11192 match k {
11193 GeneratedField::Tables => {
11194 if tables__.is_some() {
11195 return Err(serde::de::Error::duplicate_field("tables"));
11196 }
11197 tables__ = Some(
11198 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11199 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11200 );
11201 }
11202 }
11203 }
11204 Ok(GetTablesResponse {
11205 tables: tables__.unwrap_or_default(),
11206 })
11207 }
11208 }
11209 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
11210 }
11211}
11212impl serde::Serialize for ListConnectionsRequest {
11213 #[allow(deprecated)]
11214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11215 where
11216 S: serde::Serializer,
11217 {
11218 use serde::ser::SerializeStruct;
11219 let len = 0;
11220 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
11221 struct_ser.end()
11222 }
11223}
11224impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
11225 #[allow(deprecated)]
11226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11227 where
11228 D: serde::Deserializer<'de>,
11229 {
11230 const FIELDS: &[&str] = &[
11231 ];
11232
11233 #[allow(clippy::enum_variant_names)]
11234 enum GeneratedField {
11235 }
11236 impl<'de> serde::Deserialize<'de> for GeneratedField {
11237 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11238 where
11239 D: serde::Deserializer<'de>,
11240 {
11241 struct GeneratedVisitor;
11242
11243 impl serde::de::Visitor<'_> for GeneratedVisitor {
11244 type Value = GeneratedField;
11245
11246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11247 write!(formatter, "expected one of: {:?}", &FIELDS)
11248 }
11249
11250 #[allow(unused_variables)]
11251 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11252 where
11253 E: serde::de::Error,
11254 {
11255 Err(serde::de::Error::unknown_field(value, FIELDS))
11256 }
11257 }
11258 deserializer.deserialize_identifier(GeneratedVisitor)
11259 }
11260 }
11261 struct GeneratedVisitor;
11262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11263 type Value = ListConnectionsRequest;
11264
11265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11266 formatter.write_str("struct ddl_service.ListConnectionsRequest")
11267 }
11268
11269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
11270 where
11271 V: serde::de::MapAccess<'de>,
11272 {
11273 while map_.next_key::<GeneratedField>()?.is_some() {
11274 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11275 }
11276 Ok(ListConnectionsRequest {
11277 })
11278 }
11279 }
11280 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
11281 }
11282}
11283impl serde::Serialize for ListConnectionsResponse {
11284 #[allow(deprecated)]
11285 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11286 where
11287 S: serde::Serializer,
11288 {
11289 use serde::ser::SerializeStruct;
11290 let mut len = 0;
11291 if !self.connections.is_empty() {
11292 len += 1;
11293 }
11294 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
11295 if !self.connections.is_empty() {
11296 struct_ser.serialize_field("connections", &self.connections)?;
11297 }
11298 struct_ser.end()
11299 }
11300}
11301impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
11302 #[allow(deprecated)]
11303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11304 where
11305 D: serde::Deserializer<'de>,
11306 {
11307 const FIELDS: &[&str] = &[
11308 "connections",
11309 ];
11310
11311 #[allow(clippy::enum_variant_names)]
11312 enum GeneratedField {
11313 Connections,
11314 }
11315 impl<'de> serde::Deserialize<'de> for GeneratedField {
11316 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11317 where
11318 D: serde::Deserializer<'de>,
11319 {
11320 struct GeneratedVisitor;
11321
11322 impl serde::de::Visitor<'_> for GeneratedVisitor {
11323 type Value = GeneratedField;
11324
11325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11326 write!(formatter, "expected one of: {:?}", &FIELDS)
11327 }
11328
11329 #[allow(unused_variables)]
11330 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11331 where
11332 E: serde::de::Error,
11333 {
11334 match value {
11335 "connections" => Ok(GeneratedField::Connections),
11336 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11337 }
11338 }
11339 }
11340 deserializer.deserialize_identifier(GeneratedVisitor)
11341 }
11342 }
11343 struct GeneratedVisitor;
11344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11345 type Value = ListConnectionsResponse;
11346
11347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11348 formatter.write_str("struct ddl_service.ListConnectionsResponse")
11349 }
11350
11351 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
11352 where
11353 V: serde::de::MapAccess<'de>,
11354 {
11355 let mut connections__ = None;
11356 while let Some(k) = map_.next_key()? {
11357 match k {
11358 GeneratedField::Connections => {
11359 if connections__.is_some() {
11360 return Err(serde::de::Error::duplicate_field("connections"));
11361 }
11362 connections__ = Some(map_.next_value()?);
11363 }
11364 }
11365 }
11366 Ok(ListConnectionsResponse {
11367 connections: connections__.unwrap_or_default(),
11368 })
11369 }
11370 }
11371 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
11372 }
11373}
11374impl serde::Serialize for ReplaceJobPlan {
11375 #[allow(deprecated)]
11376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11377 where
11378 S: serde::Serializer,
11379 {
11380 use serde::ser::SerializeStruct;
11381 let mut len = 0;
11382 if self.fragment_graph.is_some() {
11383 len += 1;
11384 }
11385 if self.replace_job.is_some() {
11386 len += 1;
11387 }
11388 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
11389 if let Some(v) = self.fragment_graph.as_ref() {
11390 struct_ser.serialize_field("fragmentGraph", v)?;
11391 }
11392 if let Some(v) = self.replace_job.as_ref() {
11393 match v {
11394 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
11395 struct_ser.serialize_field("replaceTable", v)?;
11396 }
11397 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
11398 struct_ser.serialize_field("replaceSource", v)?;
11399 }
11400 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
11401 struct_ser.serialize_field("replaceMaterializedView", v)?;
11402 }
11403 }
11404 }
11405 struct_ser.end()
11406 }
11407}
11408impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
11409 #[allow(deprecated)]
11410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11411 where
11412 D: serde::Deserializer<'de>,
11413 {
11414 const FIELDS: &[&str] = &[
11415 "fragment_graph",
11416 "fragmentGraph",
11417 "replace_table",
11418 "replaceTable",
11419 "replace_source",
11420 "replaceSource",
11421 "replace_materialized_view",
11422 "replaceMaterializedView",
11423 ];
11424
11425 #[allow(clippy::enum_variant_names)]
11426 enum GeneratedField {
11427 FragmentGraph,
11428 ReplaceTable,
11429 ReplaceSource,
11430 ReplaceMaterializedView,
11431 }
11432 impl<'de> serde::Deserialize<'de> for GeneratedField {
11433 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11434 where
11435 D: serde::Deserializer<'de>,
11436 {
11437 struct GeneratedVisitor;
11438
11439 impl serde::de::Visitor<'_> for GeneratedVisitor {
11440 type Value = GeneratedField;
11441
11442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11443 write!(formatter, "expected one of: {:?}", &FIELDS)
11444 }
11445
11446 #[allow(unused_variables)]
11447 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11448 where
11449 E: serde::de::Error,
11450 {
11451 match value {
11452 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
11453 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
11454 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
11455 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
11456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11457 }
11458 }
11459 }
11460 deserializer.deserialize_identifier(GeneratedVisitor)
11461 }
11462 }
11463 struct GeneratedVisitor;
11464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11465 type Value = ReplaceJobPlan;
11466
11467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11468 formatter.write_str("struct ddl_service.ReplaceJobPlan")
11469 }
11470
11471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
11472 where
11473 V: serde::de::MapAccess<'de>,
11474 {
11475 let mut fragment_graph__ = None;
11476 let mut replace_job__ = None;
11477 while let Some(k) = map_.next_key()? {
11478 match k {
11479 GeneratedField::FragmentGraph => {
11480 if fragment_graph__.is_some() {
11481 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11482 }
11483 fragment_graph__ = map_.next_value()?;
11484 }
11485 GeneratedField::ReplaceTable => {
11486 if replace_job__.is_some() {
11487 return Err(serde::de::Error::duplicate_field("replaceTable"));
11488 }
11489 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11490;
11491 }
11492 GeneratedField::ReplaceSource => {
11493 if replace_job__.is_some() {
11494 return Err(serde::de::Error::duplicate_field("replaceSource"));
11495 }
11496 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11497;
11498 }
11499 GeneratedField::ReplaceMaterializedView => {
11500 if replace_job__.is_some() {
11501 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11502 }
11503 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11504;
11505 }
11506 }
11507 }
11508 Ok(ReplaceJobPlan {
11509 fragment_graph: fragment_graph__,
11510 replace_job: replace_job__,
11511 })
11512 }
11513 }
11514 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11515 }
11516}
11517impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
11518 #[allow(deprecated)]
11519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11520 where
11521 S: serde::Serializer,
11522 {
11523 use serde::ser::SerializeStruct;
11524 let mut len = 0;
11525 if self.table.is_some() {
11526 len += 1;
11527 }
11528 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11529 if let Some(v) = self.table.as_ref() {
11530 struct_ser.serialize_field("table", v)?;
11531 }
11532 struct_ser.end()
11533 }
11534}
11535impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
11536 #[allow(deprecated)]
11537 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11538 where
11539 D: serde::Deserializer<'de>,
11540 {
11541 const FIELDS: &[&str] = &[
11542 "table",
11543 ];
11544
11545 #[allow(clippy::enum_variant_names)]
11546 enum GeneratedField {
11547 Table,
11548 }
11549 impl<'de> serde::Deserialize<'de> for GeneratedField {
11550 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11551 where
11552 D: serde::Deserializer<'de>,
11553 {
11554 struct GeneratedVisitor;
11555
11556 impl serde::de::Visitor<'_> for GeneratedVisitor {
11557 type Value = GeneratedField;
11558
11559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11560 write!(formatter, "expected one of: {:?}", &FIELDS)
11561 }
11562
11563 #[allow(unused_variables)]
11564 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11565 where
11566 E: serde::de::Error,
11567 {
11568 match value {
11569 "table" => Ok(GeneratedField::Table),
11570 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11571 }
11572 }
11573 }
11574 deserializer.deserialize_identifier(GeneratedVisitor)
11575 }
11576 }
11577 struct GeneratedVisitor;
11578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11579 type Value = replace_job_plan::ReplaceMaterializedView;
11580
11581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11582 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11583 }
11584
11585 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11586 where
11587 V: serde::de::MapAccess<'de>,
11588 {
11589 let mut table__ = None;
11590 while let Some(k) = map_.next_key()? {
11591 match k {
11592 GeneratedField::Table => {
11593 if table__.is_some() {
11594 return Err(serde::de::Error::duplicate_field("table"));
11595 }
11596 table__ = map_.next_value()?;
11597 }
11598 }
11599 }
11600 Ok(replace_job_plan::ReplaceMaterializedView {
11601 table: table__,
11602 })
11603 }
11604 }
11605 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11606 }
11607}
11608impl serde::Serialize for replace_job_plan::ReplaceSource {
11609 #[allow(deprecated)]
11610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11611 where
11612 S: serde::Serializer,
11613 {
11614 use serde::ser::SerializeStruct;
11615 let mut len = 0;
11616 if self.source.is_some() {
11617 len += 1;
11618 }
11619 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11620 if let Some(v) = self.source.as_ref() {
11621 struct_ser.serialize_field("source", v)?;
11622 }
11623 struct_ser.end()
11624 }
11625}
11626impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11627 #[allow(deprecated)]
11628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11629 where
11630 D: serde::Deserializer<'de>,
11631 {
11632 const FIELDS: &[&str] = &[
11633 "source",
11634 ];
11635
11636 #[allow(clippy::enum_variant_names)]
11637 enum GeneratedField {
11638 Source,
11639 }
11640 impl<'de> serde::Deserialize<'de> for GeneratedField {
11641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11642 where
11643 D: serde::Deserializer<'de>,
11644 {
11645 struct GeneratedVisitor;
11646
11647 impl serde::de::Visitor<'_> for GeneratedVisitor {
11648 type Value = GeneratedField;
11649
11650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11651 write!(formatter, "expected one of: {:?}", &FIELDS)
11652 }
11653
11654 #[allow(unused_variables)]
11655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11656 where
11657 E: serde::de::Error,
11658 {
11659 match value {
11660 "source" => Ok(GeneratedField::Source),
11661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11662 }
11663 }
11664 }
11665 deserializer.deserialize_identifier(GeneratedVisitor)
11666 }
11667 }
11668 struct GeneratedVisitor;
11669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11670 type Value = replace_job_plan::ReplaceSource;
11671
11672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11673 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
11674 }
11675
11676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
11677 where
11678 V: serde::de::MapAccess<'de>,
11679 {
11680 let mut source__ = None;
11681 while let Some(k) = map_.next_key()? {
11682 match k {
11683 GeneratedField::Source => {
11684 if source__.is_some() {
11685 return Err(serde::de::Error::duplicate_field("source"));
11686 }
11687 source__ = map_.next_value()?;
11688 }
11689 }
11690 }
11691 Ok(replace_job_plan::ReplaceSource {
11692 source: source__,
11693 })
11694 }
11695 }
11696 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
11697 }
11698}
11699impl serde::Serialize for replace_job_plan::ReplaceTable {
11700 #[allow(deprecated)]
11701 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11702 where
11703 S: serde::Serializer,
11704 {
11705 use serde::ser::SerializeStruct;
11706 let mut len = 0;
11707 if self.table.is_some() {
11708 len += 1;
11709 }
11710 if self.source.is_some() {
11711 len += 1;
11712 }
11713 if self.job_type != 0 {
11714 len += 1;
11715 }
11716 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
11717 if let Some(v) = self.table.as_ref() {
11718 struct_ser.serialize_field("table", v)?;
11719 }
11720 if let Some(v) = self.source.as_ref() {
11721 struct_ser.serialize_field("source", v)?;
11722 }
11723 if self.job_type != 0 {
11724 let v = TableJobType::try_from(self.job_type)
11725 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
11726 struct_ser.serialize_field("jobType", &v)?;
11727 }
11728 struct_ser.end()
11729 }
11730}
11731impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
11732 #[allow(deprecated)]
11733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11734 where
11735 D: serde::Deserializer<'de>,
11736 {
11737 const FIELDS: &[&str] = &[
11738 "table",
11739 "source",
11740 "job_type",
11741 "jobType",
11742 ];
11743
11744 #[allow(clippy::enum_variant_names)]
11745 enum GeneratedField {
11746 Table,
11747 Source,
11748 JobType,
11749 }
11750 impl<'de> serde::Deserialize<'de> for GeneratedField {
11751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11752 where
11753 D: serde::Deserializer<'de>,
11754 {
11755 struct GeneratedVisitor;
11756
11757 impl serde::de::Visitor<'_> for GeneratedVisitor {
11758 type Value = GeneratedField;
11759
11760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11761 write!(formatter, "expected one of: {:?}", &FIELDS)
11762 }
11763
11764 #[allow(unused_variables)]
11765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11766 where
11767 E: serde::de::Error,
11768 {
11769 match value {
11770 "table" => Ok(GeneratedField::Table),
11771 "source" => Ok(GeneratedField::Source),
11772 "jobType" | "job_type" => Ok(GeneratedField::JobType),
11773 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11774 }
11775 }
11776 }
11777 deserializer.deserialize_identifier(GeneratedVisitor)
11778 }
11779 }
11780 struct GeneratedVisitor;
11781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11782 type Value = replace_job_plan::ReplaceTable;
11783
11784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11785 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11786 }
11787
11788 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11789 where
11790 V: serde::de::MapAccess<'de>,
11791 {
11792 let mut table__ = None;
11793 let mut source__ = None;
11794 let mut job_type__ = None;
11795 while let Some(k) = map_.next_key()? {
11796 match k {
11797 GeneratedField::Table => {
11798 if table__.is_some() {
11799 return Err(serde::de::Error::duplicate_field("table"));
11800 }
11801 table__ = map_.next_value()?;
11802 }
11803 GeneratedField::Source => {
11804 if source__.is_some() {
11805 return Err(serde::de::Error::duplicate_field("source"));
11806 }
11807 source__ = map_.next_value()?;
11808 }
11809 GeneratedField::JobType => {
11810 if job_type__.is_some() {
11811 return Err(serde::de::Error::duplicate_field("jobType"));
11812 }
11813 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11814 }
11815 }
11816 }
11817 Ok(replace_job_plan::ReplaceTable {
11818 table: table__,
11819 source: source__,
11820 job_type: job_type__.unwrap_or_default(),
11821 })
11822 }
11823 }
11824 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11825 }
11826}
11827impl serde::Serialize for ReplaceJobPlanRequest {
11828 #[allow(deprecated)]
11829 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11830 where
11831 S: serde::Serializer,
11832 {
11833 use serde::ser::SerializeStruct;
11834 let mut len = 0;
11835 if self.plan.is_some() {
11836 len += 1;
11837 }
11838 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11839 if let Some(v) = self.plan.as_ref() {
11840 struct_ser.serialize_field("plan", v)?;
11841 }
11842 struct_ser.end()
11843 }
11844}
11845impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11846 #[allow(deprecated)]
11847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11848 where
11849 D: serde::Deserializer<'de>,
11850 {
11851 const FIELDS: &[&str] = &[
11852 "plan",
11853 ];
11854
11855 #[allow(clippy::enum_variant_names)]
11856 enum GeneratedField {
11857 Plan,
11858 }
11859 impl<'de> serde::Deserialize<'de> for GeneratedField {
11860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11861 where
11862 D: serde::Deserializer<'de>,
11863 {
11864 struct GeneratedVisitor;
11865
11866 impl serde::de::Visitor<'_> for GeneratedVisitor {
11867 type Value = GeneratedField;
11868
11869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11870 write!(formatter, "expected one of: {:?}", &FIELDS)
11871 }
11872
11873 #[allow(unused_variables)]
11874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11875 where
11876 E: serde::de::Error,
11877 {
11878 match value {
11879 "plan" => Ok(GeneratedField::Plan),
11880 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11881 }
11882 }
11883 }
11884 deserializer.deserialize_identifier(GeneratedVisitor)
11885 }
11886 }
11887 struct GeneratedVisitor;
11888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11889 type Value = ReplaceJobPlanRequest;
11890
11891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11892 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11893 }
11894
11895 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11896 where
11897 V: serde::de::MapAccess<'de>,
11898 {
11899 let mut plan__ = None;
11900 while let Some(k) = map_.next_key()? {
11901 match k {
11902 GeneratedField::Plan => {
11903 if plan__.is_some() {
11904 return Err(serde::de::Error::duplicate_field("plan"));
11905 }
11906 plan__ = map_.next_value()?;
11907 }
11908 }
11909 }
11910 Ok(ReplaceJobPlanRequest {
11911 plan: plan__,
11912 })
11913 }
11914 }
11915 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11916 }
11917}
11918impl serde::Serialize for ReplaceJobPlanResponse {
11919 #[allow(deprecated)]
11920 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11921 where
11922 S: serde::Serializer,
11923 {
11924 use serde::ser::SerializeStruct;
11925 let mut len = 0;
11926 if self.status.is_some() {
11927 len += 1;
11928 }
11929 if self.version.is_some() {
11930 len += 1;
11931 }
11932 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11933 if let Some(v) = self.status.as_ref() {
11934 struct_ser.serialize_field("status", v)?;
11935 }
11936 if let Some(v) = self.version.as_ref() {
11937 struct_ser.serialize_field("version", v)?;
11938 }
11939 struct_ser.end()
11940 }
11941}
11942impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
11943 #[allow(deprecated)]
11944 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11945 where
11946 D: serde::Deserializer<'de>,
11947 {
11948 const FIELDS: &[&str] = &[
11949 "status",
11950 "version",
11951 ];
11952
11953 #[allow(clippy::enum_variant_names)]
11954 enum GeneratedField {
11955 Status,
11956 Version,
11957 }
11958 impl<'de> serde::Deserialize<'de> for GeneratedField {
11959 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11960 where
11961 D: serde::Deserializer<'de>,
11962 {
11963 struct GeneratedVisitor;
11964
11965 impl serde::de::Visitor<'_> for GeneratedVisitor {
11966 type Value = GeneratedField;
11967
11968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11969 write!(formatter, "expected one of: {:?}", &FIELDS)
11970 }
11971
11972 #[allow(unused_variables)]
11973 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11974 where
11975 E: serde::de::Error,
11976 {
11977 match value {
11978 "status" => Ok(GeneratedField::Status),
11979 "version" => Ok(GeneratedField::Version),
11980 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11981 }
11982 }
11983 }
11984 deserializer.deserialize_identifier(GeneratedVisitor)
11985 }
11986 }
11987 struct GeneratedVisitor;
11988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11989 type Value = ReplaceJobPlanResponse;
11990
11991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11992 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
11993 }
11994
11995 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
11996 where
11997 V: serde::de::MapAccess<'de>,
11998 {
11999 let mut status__ = None;
12000 let mut version__ = None;
12001 while let Some(k) = map_.next_key()? {
12002 match k {
12003 GeneratedField::Status => {
12004 if status__.is_some() {
12005 return Err(serde::de::Error::duplicate_field("status"));
12006 }
12007 status__ = map_.next_value()?;
12008 }
12009 GeneratedField::Version => {
12010 if version__.is_some() {
12011 return Err(serde::de::Error::duplicate_field("version"));
12012 }
12013 version__ = map_.next_value()?;
12014 }
12015 }
12016 }
12017 Ok(ReplaceJobPlanResponse {
12018 status: status__,
12019 version: version__,
12020 })
12021 }
12022 }
12023 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
12024 }
12025}
12026impl serde::Serialize for ResetSourceRequest {
12027 #[allow(deprecated)]
12028 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12029 where
12030 S: serde::Serializer,
12031 {
12032 use serde::ser::SerializeStruct;
12033 let mut len = 0;
12034 if self.source_id != 0 {
12035 len += 1;
12036 }
12037 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
12038 if self.source_id != 0 {
12039 struct_ser.serialize_field("sourceId", &self.source_id)?;
12040 }
12041 struct_ser.end()
12042 }
12043}
12044impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
12045 #[allow(deprecated)]
12046 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12047 where
12048 D: serde::Deserializer<'de>,
12049 {
12050 const FIELDS: &[&str] = &[
12051 "source_id",
12052 "sourceId",
12053 ];
12054
12055 #[allow(clippy::enum_variant_names)]
12056 enum GeneratedField {
12057 SourceId,
12058 }
12059 impl<'de> serde::Deserialize<'de> for GeneratedField {
12060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12061 where
12062 D: serde::Deserializer<'de>,
12063 {
12064 struct GeneratedVisitor;
12065
12066 impl serde::de::Visitor<'_> for GeneratedVisitor {
12067 type Value = GeneratedField;
12068
12069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12070 write!(formatter, "expected one of: {:?}", &FIELDS)
12071 }
12072
12073 #[allow(unused_variables)]
12074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12075 where
12076 E: serde::de::Error,
12077 {
12078 match value {
12079 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12081 }
12082 }
12083 }
12084 deserializer.deserialize_identifier(GeneratedVisitor)
12085 }
12086 }
12087 struct GeneratedVisitor;
12088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12089 type Value = ResetSourceRequest;
12090
12091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12092 formatter.write_str("struct ddl_service.ResetSourceRequest")
12093 }
12094
12095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
12096 where
12097 V: serde::de::MapAccess<'de>,
12098 {
12099 let mut source_id__ = None;
12100 while let Some(k) = map_.next_key()? {
12101 match k {
12102 GeneratedField::SourceId => {
12103 if source_id__.is_some() {
12104 return Err(serde::de::Error::duplicate_field("sourceId"));
12105 }
12106 source_id__ =
12107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12108 ;
12109 }
12110 }
12111 }
12112 Ok(ResetSourceRequest {
12113 source_id: source_id__.unwrap_or_default(),
12114 })
12115 }
12116 }
12117 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
12118 }
12119}
12120impl serde::Serialize for ResetSourceResponse {
12121 #[allow(deprecated)]
12122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12123 where
12124 S: serde::Serializer,
12125 {
12126 use serde::ser::SerializeStruct;
12127 let mut len = 0;
12128 if self.status.is_some() {
12129 len += 1;
12130 }
12131 if self.version.is_some() {
12132 len += 1;
12133 }
12134 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
12135 if let Some(v) = self.status.as_ref() {
12136 struct_ser.serialize_field("status", v)?;
12137 }
12138 if let Some(v) = self.version.as_ref() {
12139 struct_ser.serialize_field("version", v)?;
12140 }
12141 struct_ser.end()
12142 }
12143}
12144impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
12145 #[allow(deprecated)]
12146 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12147 where
12148 D: serde::Deserializer<'de>,
12149 {
12150 const FIELDS: &[&str] = &[
12151 "status",
12152 "version",
12153 ];
12154
12155 #[allow(clippy::enum_variant_names)]
12156 enum GeneratedField {
12157 Status,
12158 Version,
12159 }
12160 impl<'de> serde::Deserialize<'de> for GeneratedField {
12161 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12162 where
12163 D: serde::Deserializer<'de>,
12164 {
12165 struct GeneratedVisitor;
12166
12167 impl serde::de::Visitor<'_> for GeneratedVisitor {
12168 type Value = GeneratedField;
12169
12170 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12171 write!(formatter, "expected one of: {:?}", &FIELDS)
12172 }
12173
12174 #[allow(unused_variables)]
12175 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12176 where
12177 E: serde::de::Error,
12178 {
12179 match value {
12180 "status" => Ok(GeneratedField::Status),
12181 "version" => Ok(GeneratedField::Version),
12182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12183 }
12184 }
12185 }
12186 deserializer.deserialize_identifier(GeneratedVisitor)
12187 }
12188 }
12189 struct GeneratedVisitor;
12190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12191 type Value = ResetSourceResponse;
12192
12193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12194 formatter.write_str("struct ddl_service.ResetSourceResponse")
12195 }
12196
12197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
12198 where
12199 V: serde::de::MapAccess<'de>,
12200 {
12201 let mut status__ = None;
12202 let mut version__ = None;
12203 while let Some(k) = map_.next_key()? {
12204 match k {
12205 GeneratedField::Status => {
12206 if status__.is_some() {
12207 return Err(serde::de::Error::duplicate_field("status"));
12208 }
12209 status__ = map_.next_value()?;
12210 }
12211 GeneratedField::Version => {
12212 if version__.is_some() {
12213 return Err(serde::de::Error::duplicate_field("version"));
12214 }
12215 version__ = map_.next_value()?;
12216 }
12217 }
12218 }
12219 Ok(ResetSourceResponse {
12220 status: status__,
12221 version: version__,
12222 })
12223 }
12224 }
12225 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
12226 }
12227}
12228impl serde::Serialize for RisectlListStateTablesRequest {
12229 #[allow(deprecated)]
12230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12231 where
12232 S: serde::Serializer,
12233 {
12234 use serde::ser::SerializeStruct;
12235 let len = 0;
12236 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
12237 struct_ser.end()
12238 }
12239}
12240impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
12241 #[allow(deprecated)]
12242 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12243 where
12244 D: serde::Deserializer<'de>,
12245 {
12246 const FIELDS: &[&str] = &[
12247 ];
12248
12249 #[allow(clippy::enum_variant_names)]
12250 enum GeneratedField {
12251 }
12252 impl<'de> serde::Deserialize<'de> for GeneratedField {
12253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12254 where
12255 D: serde::Deserializer<'de>,
12256 {
12257 struct GeneratedVisitor;
12258
12259 impl serde::de::Visitor<'_> for GeneratedVisitor {
12260 type Value = GeneratedField;
12261
12262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12263 write!(formatter, "expected one of: {:?}", &FIELDS)
12264 }
12265
12266 #[allow(unused_variables)]
12267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12268 where
12269 E: serde::de::Error,
12270 {
12271 Err(serde::de::Error::unknown_field(value, FIELDS))
12272 }
12273 }
12274 deserializer.deserialize_identifier(GeneratedVisitor)
12275 }
12276 }
12277 struct GeneratedVisitor;
12278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12279 type Value = RisectlListStateTablesRequest;
12280
12281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12282 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
12283 }
12284
12285 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
12286 where
12287 V: serde::de::MapAccess<'de>,
12288 {
12289 while map_.next_key::<GeneratedField>()?.is_some() {
12290 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12291 }
12292 Ok(RisectlListStateTablesRequest {
12293 })
12294 }
12295 }
12296 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
12297 }
12298}
12299impl serde::Serialize for RisectlListStateTablesResponse {
12300 #[allow(deprecated)]
12301 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12302 where
12303 S: serde::Serializer,
12304 {
12305 use serde::ser::SerializeStruct;
12306 let mut len = 0;
12307 if !self.tables.is_empty() {
12308 len += 1;
12309 }
12310 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
12311 if !self.tables.is_empty() {
12312 struct_ser.serialize_field("tables", &self.tables)?;
12313 }
12314 struct_ser.end()
12315 }
12316}
12317impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
12318 #[allow(deprecated)]
12319 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12320 where
12321 D: serde::Deserializer<'de>,
12322 {
12323 const FIELDS: &[&str] = &[
12324 "tables",
12325 ];
12326
12327 #[allow(clippy::enum_variant_names)]
12328 enum GeneratedField {
12329 Tables,
12330 }
12331 impl<'de> serde::Deserialize<'de> for GeneratedField {
12332 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12333 where
12334 D: serde::Deserializer<'de>,
12335 {
12336 struct GeneratedVisitor;
12337
12338 impl serde::de::Visitor<'_> for GeneratedVisitor {
12339 type Value = GeneratedField;
12340
12341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12342 write!(formatter, "expected one of: {:?}", &FIELDS)
12343 }
12344
12345 #[allow(unused_variables)]
12346 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12347 where
12348 E: serde::de::Error,
12349 {
12350 match value {
12351 "tables" => Ok(GeneratedField::Tables),
12352 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12353 }
12354 }
12355 }
12356 deserializer.deserialize_identifier(GeneratedVisitor)
12357 }
12358 }
12359 struct GeneratedVisitor;
12360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12361 type Value = RisectlListStateTablesResponse;
12362
12363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12364 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
12365 }
12366
12367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
12368 where
12369 V: serde::de::MapAccess<'de>,
12370 {
12371 let mut tables__ = None;
12372 while let Some(k) = map_.next_key()? {
12373 match k {
12374 GeneratedField::Tables => {
12375 if tables__.is_some() {
12376 return Err(serde::de::Error::duplicate_field("tables"));
12377 }
12378 tables__ = Some(map_.next_value()?);
12379 }
12380 }
12381 }
12382 Ok(RisectlListStateTablesResponse {
12383 tables: tables__.unwrap_or_default(),
12384 })
12385 }
12386 }
12387 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
12388 }
12389}
12390impl serde::Serialize for RisectlResumeBackfillRequest {
12391 #[allow(deprecated)]
12392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12393 where
12394 S: serde::Serializer,
12395 {
12396 use serde::ser::SerializeStruct;
12397 let mut len = 0;
12398 if self.target.is_some() {
12399 len += 1;
12400 }
12401 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillRequest", len)?;
12402 if let Some(v) = self.target.as_ref() {
12403 match v {
12404 risectl_resume_backfill_request::Target::JobId(v) => {
12405 struct_ser.serialize_field("jobId", v)?;
12406 }
12407 risectl_resume_backfill_request::Target::FragmentId(v) => {
12408 struct_ser.serialize_field("fragmentId", v)?;
12409 }
12410 }
12411 }
12412 struct_ser.end()
12413 }
12414}
12415impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillRequest {
12416 #[allow(deprecated)]
12417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12418 where
12419 D: serde::Deserializer<'de>,
12420 {
12421 const FIELDS: &[&str] = &[
12422 "job_id",
12423 "jobId",
12424 "fragment_id",
12425 "fragmentId",
12426 ];
12427
12428 #[allow(clippy::enum_variant_names)]
12429 enum GeneratedField {
12430 JobId,
12431 FragmentId,
12432 }
12433 impl<'de> serde::Deserialize<'de> for GeneratedField {
12434 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12435 where
12436 D: serde::Deserializer<'de>,
12437 {
12438 struct GeneratedVisitor;
12439
12440 impl serde::de::Visitor<'_> for GeneratedVisitor {
12441 type Value = GeneratedField;
12442
12443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12444 write!(formatter, "expected one of: {:?}", &FIELDS)
12445 }
12446
12447 #[allow(unused_variables)]
12448 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12449 where
12450 E: serde::de::Error,
12451 {
12452 match value {
12453 "jobId" | "job_id" => Ok(GeneratedField::JobId),
12454 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12455 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12456 }
12457 }
12458 }
12459 deserializer.deserialize_identifier(GeneratedVisitor)
12460 }
12461 }
12462 struct GeneratedVisitor;
12463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12464 type Value = RisectlResumeBackfillRequest;
12465
12466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12467 formatter.write_str("struct ddl_service.RisectlResumeBackfillRequest")
12468 }
12469
12470 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillRequest, V::Error>
12471 where
12472 V: serde::de::MapAccess<'de>,
12473 {
12474 let mut target__ = None;
12475 while let Some(k) = map_.next_key()? {
12476 match k {
12477 GeneratedField::JobId => {
12478 if target__.is_some() {
12479 return Err(serde::de::Error::duplicate_field("jobId"));
12480 }
12481 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::JobId(x.0));
12482 }
12483 GeneratedField::FragmentId => {
12484 if target__.is_some() {
12485 return Err(serde::de::Error::duplicate_field("fragmentId"));
12486 }
12487 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::FragmentId(x.0));
12488 }
12489 }
12490 }
12491 Ok(RisectlResumeBackfillRequest {
12492 target: target__,
12493 })
12494 }
12495 }
12496 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillRequest", FIELDS, GeneratedVisitor)
12497 }
12498}
12499impl serde::Serialize for RisectlResumeBackfillResponse {
12500 #[allow(deprecated)]
12501 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12502 where
12503 S: serde::Serializer,
12504 {
12505 use serde::ser::SerializeStruct;
12506 let len = 0;
12507 let struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillResponse", len)?;
12508 struct_ser.end()
12509 }
12510}
12511impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillResponse {
12512 #[allow(deprecated)]
12513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12514 where
12515 D: serde::Deserializer<'de>,
12516 {
12517 const FIELDS: &[&str] = &[
12518 ];
12519
12520 #[allow(clippy::enum_variant_names)]
12521 enum GeneratedField {
12522 }
12523 impl<'de> serde::Deserialize<'de> for GeneratedField {
12524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12525 where
12526 D: serde::Deserializer<'de>,
12527 {
12528 struct GeneratedVisitor;
12529
12530 impl serde::de::Visitor<'_> for GeneratedVisitor {
12531 type Value = GeneratedField;
12532
12533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12534 write!(formatter, "expected one of: {:?}", &FIELDS)
12535 }
12536
12537 #[allow(unused_variables)]
12538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12539 where
12540 E: serde::de::Error,
12541 {
12542 Err(serde::de::Error::unknown_field(value, FIELDS))
12543 }
12544 }
12545 deserializer.deserialize_identifier(GeneratedVisitor)
12546 }
12547 }
12548 struct GeneratedVisitor;
12549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12550 type Value = RisectlResumeBackfillResponse;
12551
12552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12553 formatter.write_str("struct ddl_service.RisectlResumeBackfillResponse")
12554 }
12555
12556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillResponse, V::Error>
12557 where
12558 V: serde::de::MapAccess<'de>,
12559 {
12560 while map_.next_key::<GeneratedField>()?.is_some() {
12561 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12562 }
12563 Ok(RisectlResumeBackfillResponse {
12564 })
12565 }
12566 }
12567 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillResponse", FIELDS, GeneratedVisitor)
12568 }
12569}
12570impl serde::Serialize for SchemaChangeEnvelope {
12571 #[allow(deprecated)]
12572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12573 where
12574 S: serde::Serializer,
12575 {
12576 use serde::ser::SerializeStruct;
12577 let mut len = 0;
12578 if !self.table_changes.is_empty() {
12579 len += 1;
12580 }
12581 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
12582 if !self.table_changes.is_empty() {
12583 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
12584 }
12585 struct_ser.end()
12586 }
12587}
12588impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
12589 #[allow(deprecated)]
12590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12591 where
12592 D: serde::Deserializer<'de>,
12593 {
12594 const FIELDS: &[&str] = &[
12595 "table_changes",
12596 "tableChanges",
12597 ];
12598
12599 #[allow(clippy::enum_variant_names)]
12600 enum GeneratedField {
12601 TableChanges,
12602 }
12603 impl<'de> serde::Deserialize<'de> for GeneratedField {
12604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12605 where
12606 D: serde::Deserializer<'de>,
12607 {
12608 struct GeneratedVisitor;
12609
12610 impl serde::de::Visitor<'_> for GeneratedVisitor {
12611 type Value = GeneratedField;
12612
12613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12614 write!(formatter, "expected one of: {:?}", &FIELDS)
12615 }
12616
12617 #[allow(unused_variables)]
12618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12619 where
12620 E: serde::de::Error,
12621 {
12622 match value {
12623 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
12624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12625 }
12626 }
12627 }
12628 deserializer.deserialize_identifier(GeneratedVisitor)
12629 }
12630 }
12631 struct GeneratedVisitor;
12632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12633 type Value = SchemaChangeEnvelope;
12634
12635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12636 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
12637 }
12638
12639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
12640 where
12641 V: serde::de::MapAccess<'de>,
12642 {
12643 let mut table_changes__ = None;
12644 while let Some(k) = map_.next_key()? {
12645 match k {
12646 GeneratedField::TableChanges => {
12647 if table_changes__.is_some() {
12648 return Err(serde::de::Error::duplicate_field("tableChanges"));
12649 }
12650 table_changes__ = Some(map_.next_value()?);
12651 }
12652 }
12653 }
12654 Ok(SchemaChangeEnvelope {
12655 table_changes: table_changes__.unwrap_or_default(),
12656 })
12657 }
12658 }
12659 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
12660 }
12661}
12662impl serde::Serialize for StreamingJobResourceType {
12663 #[allow(deprecated)]
12664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12665 where
12666 S: serde::Serializer,
12667 {
12668 use serde::ser::SerializeStruct;
12669 let mut len = 0;
12670 if self.resource_type.is_some() {
12671 len += 1;
12672 }
12673 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
12674 if let Some(v) = self.resource_type.as_ref() {
12675 match v {
12676 streaming_job_resource_type::ResourceType::Regular(v) => {
12677 struct_ser.serialize_field("regular", v)?;
12678 }
12679 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
12680 struct_ser.serialize_field("specificResourceGroup", v)?;
12681 }
12682 streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup(v) => {
12683 struct_ser.serialize_field("serverlessBackfillResourceGroup", v)?;
12684 }
12685 }
12686 }
12687 struct_ser.end()
12688 }
12689}
12690impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
12691 #[allow(deprecated)]
12692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12693 where
12694 D: serde::Deserializer<'de>,
12695 {
12696 const FIELDS: &[&str] = &[
12697 "regular",
12698 "specific_resource_group",
12699 "specificResourceGroup",
12700 "serverless_backfill_resource_group",
12701 "serverlessBackfillResourceGroup",
12702 ];
12703
12704 #[allow(clippy::enum_variant_names)]
12705 enum GeneratedField {
12706 Regular,
12707 SpecificResourceGroup,
12708 ServerlessBackfillResourceGroup,
12709 }
12710 impl<'de> serde::Deserialize<'de> for GeneratedField {
12711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12712 where
12713 D: serde::Deserializer<'de>,
12714 {
12715 struct GeneratedVisitor;
12716
12717 impl serde::de::Visitor<'_> for GeneratedVisitor {
12718 type Value = GeneratedField;
12719
12720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12721 write!(formatter, "expected one of: {:?}", &FIELDS)
12722 }
12723
12724 #[allow(unused_variables)]
12725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12726 where
12727 E: serde::de::Error,
12728 {
12729 match value {
12730 "regular" => Ok(GeneratedField::Regular),
12731 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
12732 "serverlessBackfillResourceGroup" | "serverless_backfill_resource_group" => Ok(GeneratedField::ServerlessBackfillResourceGroup),
12733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12734 }
12735 }
12736 }
12737 deserializer.deserialize_identifier(GeneratedVisitor)
12738 }
12739 }
12740 struct GeneratedVisitor;
12741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12742 type Value = StreamingJobResourceType;
12743
12744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12745 formatter.write_str("struct ddl_service.StreamingJobResourceType")
12746 }
12747
12748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
12749 where
12750 V: serde::de::MapAccess<'de>,
12751 {
12752 let mut resource_type__ = None;
12753 while let Some(k) = map_.next_key()? {
12754 match k {
12755 GeneratedField::Regular => {
12756 if resource_type__.is_some() {
12757 return Err(serde::de::Error::duplicate_field("regular"));
12758 }
12759 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
12760 }
12761 GeneratedField::SpecificResourceGroup => {
12762 if resource_type__.is_some() {
12763 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
12764 }
12765 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
12766 }
12767 GeneratedField::ServerlessBackfillResourceGroup => {
12768 if resource_type__.is_some() {
12769 return Err(serde::de::Error::duplicate_field("serverlessBackfillResourceGroup"));
12770 }
12771 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup);
12772 }
12773 }
12774 }
12775 Ok(StreamingJobResourceType {
12776 resource_type: resource_type__,
12777 })
12778 }
12779 }
12780 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
12781 }
12782}
12783impl serde::Serialize for TableJobType {
12784 #[allow(deprecated)]
12785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12786 where
12787 S: serde::Serializer,
12788 {
12789 let variant = match self {
12790 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
12791 Self::General => "TABLE_JOB_TYPE_GENERAL",
12792 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12793 };
12794 serializer.serialize_str(variant)
12795 }
12796}
12797impl<'de> serde::Deserialize<'de> for TableJobType {
12798 #[allow(deprecated)]
12799 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12800 where
12801 D: serde::Deserializer<'de>,
12802 {
12803 const FIELDS: &[&str] = &[
12804 "TABLE_JOB_TYPE_UNSPECIFIED",
12805 "TABLE_JOB_TYPE_GENERAL",
12806 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12807 ];
12808
12809 struct GeneratedVisitor;
12810
12811 impl serde::de::Visitor<'_> for GeneratedVisitor {
12812 type Value = TableJobType;
12813
12814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12815 write!(formatter, "expected one of: {:?}", &FIELDS)
12816 }
12817
12818 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12819 where
12820 E: serde::de::Error,
12821 {
12822 i32::try_from(v)
12823 .ok()
12824 .and_then(|x| x.try_into().ok())
12825 .ok_or_else(|| {
12826 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12827 })
12828 }
12829
12830 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12831 where
12832 E: serde::de::Error,
12833 {
12834 i32::try_from(v)
12835 .ok()
12836 .and_then(|x| x.try_into().ok())
12837 .ok_or_else(|| {
12838 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12839 })
12840 }
12841
12842 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12843 where
12844 E: serde::de::Error,
12845 {
12846 match value {
12847 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
12848 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
12849 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
12850 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12851 }
12852 }
12853 }
12854 deserializer.deserialize_any(GeneratedVisitor)
12855 }
12856}
12857impl serde::Serialize for TableSchemaChange {
12858 #[allow(deprecated)]
12859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12860 where
12861 S: serde::Serializer,
12862 {
12863 use serde::ser::SerializeStruct;
12864 let mut len = 0;
12865 if self.change_type != 0 {
12866 len += 1;
12867 }
12868 if !self.cdc_table_id.is_empty() {
12869 len += 1;
12870 }
12871 if !self.columns.is_empty() {
12872 len += 1;
12873 }
12874 if !self.upstream_ddl.is_empty() {
12875 len += 1;
12876 }
12877 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
12878 if self.change_type != 0 {
12879 let v = table_schema_change::TableChangeType::try_from(self.change_type)
12880 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
12881 struct_ser.serialize_field("changeType", &v)?;
12882 }
12883 if !self.cdc_table_id.is_empty() {
12884 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
12885 }
12886 if !self.columns.is_empty() {
12887 struct_ser.serialize_field("columns", &self.columns)?;
12888 }
12889 if !self.upstream_ddl.is_empty() {
12890 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
12891 }
12892 struct_ser.end()
12893 }
12894}
12895impl<'de> serde::Deserialize<'de> for TableSchemaChange {
12896 #[allow(deprecated)]
12897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12898 where
12899 D: serde::Deserializer<'de>,
12900 {
12901 const FIELDS: &[&str] = &[
12902 "change_type",
12903 "changeType",
12904 "cdc_table_id",
12905 "cdcTableId",
12906 "columns",
12907 "upstream_ddl",
12908 "upstreamDdl",
12909 ];
12910
12911 #[allow(clippy::enum_variant_names)]
12912 enum GeneratedField {
12913 ChangeType,
12914 CdcTableId,
12915 Columns,
12916 UpstreamDdl,
12917 }
12918 impl<'de> serde::Deserialize<'de> for GeneratedField {
12919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12920 where
12921 D: serde::Deserializer<'de>,
12922 {
12923 struct GeneratedVisitor;
12924
12925 impl serde::de::Visitor<'_> for GeneratedVisitor {
12926 type Value = GeneratedField;
12927
12928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12929 write!(formatter, "expected one of: {:?}", &FIELDS)
12930 }
12931
12932 #[allow(unused_variables)]
12933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12934 where
12935 E: serde::de::Error,
12936 {
12937 match value {
12938 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
12939 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
12940 "columns" => Ok(GeneratedField::Columns),
12941 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
12942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12943 }
12944 }
12945 }
12946 deserializer.deserialize_identifier(GeneratedVisitor)
12947 }
12948 }
12949 struct GeneratedVisitor;
12950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12951 type Value = TableSchemaChange;
12952
12953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12954 formatter.write_str("struct ddl_service.TableSchemaChange")
12955 }
12956
12957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
12958 where
12959 V: serde::de::MapAccess<'de>,
12960 {
12961 let mut change_type__ = None;
12962 let mut cdc_table_id__ = None;
12963 let mut columns__ = None;
12964 let mut upstream_ddl__ = None;
12965 while let Some(k) = map_.next_key()? {
12966 match k {
12967 GeneratedField::ChangeType => {
12968 if change_type__.is_some() {
12969 return Err(serde::de::Error::duplicate_field("changeType"));
12970 }
12971 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
12972 }
12973 GeneratedField::CdcTableId => {
12974 if cdc_table_id__.is_some() {
12975 return Err(serde::de::Error::duplicate_field("cdcTableId"));
12976 }
12977 cdc_table_id__ = Some(map_.next_value()?);
12978 }
12979 GeneratedField::Columns => {
12980 if columns__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("columns"));
12982 }
12983 columns__ = Some(map_.next_value()?);
12984 }
12985 GeneratedField::UpstreamDdl => {
12986 if upstream_ddl__.is_some() {
12987 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
12988 }
12989 upstream_ddl__ = Some(map_.next_value()?);
12990 }
12991 }
12992 }
12993 Ok(TableSchemaChange {
12994 change_type: change_type__.unwrap_or_default(),
12995 cdc_table_id: cdc_table_id__.unwrap_or_default(),
12996 columns: columns__.unwrap_or_default(),
12997 upstream_ddl: upstream_ddl__.unwrap_or_default(),
12998 })
12999 }
13000 }
13001 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
13002 }
13003}
13004impl serde::Serialize for table_schema_change::TableChangeType {
13005 #[allow(deprecated)]
13006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13007 where
13008 S: serde::Serializer,
13009 {
13010 let variant = match self {
13011 Self::Unspecified => "UNSPECIFIED",
13012 Self::Alter => "ALTER",
13013 Self::Create => "CREATE",
13014 Self::Drop => "DROP",
13015 };
13016 serializer.serialize_str(variant)
13017 }
13018}
13019impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
13020 #[allow(deprecated)]
13021 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13022 where
13023 D: serde::Deserializer<'de>,
13024 {
13025 const FIELDS: &[&str] = &[
13026 "UNSPECIFIED",
13027 "ALTER",
13028 "CREATE",
13029 "DROP",
13030 ];
13031
13032 struct GeneratedVisitor;
13033
13034 impl serde::de::Visitor<'_> for GeneratedVisitor {
13035 type Value = table_schema_change::TableChangeType;
13036
13037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13038 write!(formatter, "expected one of: {:?}", &FIELDS)
13039 }
13040
13041 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13042 where
13043 E: serde::de::Error,
13044 {
13045 i32::try_from(v)
13046 .ok()
13047 .and_then(|x| x.try_into().ok())
13048 .ok_or_else(|| {
13049 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13050 })
13051 }
13052
13053 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13054 where
13055 E: serde::de::Error,
13056 {
13057 i32::try_from(v)
13058 .ok()
13059 .and_then(|x| x.try_into().ok())
13060 .ok_or_else(|| {
13061 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13062 })
13063 }
13064
13065 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13066 where
13067 E: serde::de::Error,
13068 {
13069 match value {
13070 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
13071 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
13072 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
13073 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
13074 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13075 }
13076 }
13077 }
13078 deserializer.deserialize_any(GeneratedVisitor)
13079 }
13080}
13081impl serde::Serialize for WaitRequest {
13082 #[allow(deprecated)]
13083 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13084 where
13085 S: serde::Serializer,
13086 {
13087 use serde::ser::SerializeStruct;
13088 let len = 0;
13089 let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
13090 struct_ser.end()
13091 }
13092}
13093impl<'de> serde::Deserialize<'de> for WaitRequest {
13094 #[allow(deprecated)]
13095 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13096 where
13097 D: serde::Deserializer<'de>,
13098 {
13099 const FIELDS: &[&str] = &[
13100 ];
13101
13102 #[allow(clippy::enum_variant_names)]
13103 enum GeneratedField {
13104 }
13105 impl<'de> serde::Deserialize<'de> for GeneratedField {
13106 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13107 where
13108 D: serde::Deserializer<'de>,
13109 {
13110 struct GeneratedVisitor;
13111
13112 impl serde::de::Visitor<'_> for GeneratedVisitor {
13113 type Value = GeneratedField;
13114
13115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13116 write!(formatter, "expected one of: {:?}", &FIELDS)
13117 }
13118
13119 #[allow(unused_variables)]
13120 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13121 where
13122 E: serde::de::Error,
13123 {
13124 Err(serde::de::Error::unknown_field(value, FIELDS))
13125 }
13126 }
13127 deserializer.deserialize_identifier(GeneratedVisitor)
13128 }
13129 }
13130 struct GeneratedVisitor;
13131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13132 type Value = WaitRequest;
13133
13134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13135 formatter.write_str("struct ddl_service.WaitRequest")
13136 }
13137
13138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
13139 where
13140 V: serde::de::MapAccess<'de>,
13141 {
13142 while map_.next_key::<GeneratedField>()?.is_some() {
13143 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13144 }
13145 Ok(WaitRequest {
13146 })
13147 }
13148 }
13149 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
13150 }
13151}
13152impl serde::Serialize for WaitResponse {
13153 #[allow(deprecated)]
13154 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13155 where
13156 S: serde::Serializer,
13157 {
13158 use serde::ser::SerializeStruct;
13159 let mut len = 0;
13160 if self.version.is_some() {
13161 len += 1;
13162 }
13163 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
13164 if let Some(v) = self.version.as_ref() {
13165 struct_ser.serialize_field("version", v)?;
13166 }
13167 struct_ser.end()
13168 }
13169}
13170impl<'de> serde::Deserialize<'de> for WaitResponse {
13171 #[allow(deprecated)]
13172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13173 where
13174 D: serde::Deserializer<'de>,
13175 {
13176 const FIELDS: &[&str] = &[
13177 "version",
13178 ];
13179
13180 #[allow(clippy::enum_variant_names)]
13181 enum GeneratedField {
13182 Version,
13183 }
13184 impl<'de> serde::Deserialize<'de> for GeneratedField {
13185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13186 where
13187 D: serde::Deserializer<'de>,
13188 {
13189 struct GeneratedVisitor;
13190
13191 impl serde::de::Visitor<'_> for GeneratedVisitor {
13192 type Value = GeneratedField;
13193
13194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13195 write!(formatter, "expected one of: {:?}", &FIELDS)
13196 }
13197
13198 #[allow(unused_variables)]
13199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13200 where
13201 E: serde::de::Error,
13202 {
13203 match value {
13204 "version" => Ok(GeneratedField::Version),
13205 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13206 }
13207 }
13208 }
13209 deserializer.deserialize_identifier(GeneratedVisitor)
13210 }
13211 }
13212 struct GeneratedVisitor;
13213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13214 type Value = WaitResponse;
13215
13216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13217 formatter.write_str("struct ddl_service.WaitResponse")
13218 }
13219
13220 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
13221 where
13222 V: serde::de::MapAccess<'de>,
13223 {
13224 let mut version__ = None;
13225 while let Some(k) = map_.next_key()? {
13226 match k {
13227 GeneratedField::Version => {
13228 if version__.is_some() {
13229 return Err(serde::de::Error::duplicate_field("version"));
13230 }
13231 version__ = map_.next_value()?;
13232 }
13233 }
13234 }
13235 Ok(WaitResponse {
13236 version: version__,
13237 })
13238 }
13239 }
13240 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
13241 }
13242}
13243impl serde::Serialize for WaitVersion {
13244 #[allow(deprecated)]
13245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13246 where
13247 S: serde::Serializer,
13248 {
13249 use serde::ser::SerializeStruct;
13250 let mut len = 0;
13251 if self.catalog_version != 0 {
13252 len += 1;
13253 }
13254 if self.hummock_version_id != 0 {
13255 len += 1;
13256 }
13257 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
13258 if self.catalog_version != 0 {
13259 #[allow(clippy::needless_borrow)]
13260 #[allow(clippy::needless_borrows_for_generic_args)]
13261 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13262 }
13263 if self.hummock_version_id != 0 {
13264 #[allow(clippy::needless_borrow)]
13265 #[allow(clippy::needless_borrows_for_generic_args)]
13266 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
13267 }
13268 struct_ser.end()
13269 }
13270}
13271impl<'de> serde::Deserialize<'de> for WaitVersion {
13272 #[allow(deprecated)]
13273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13274 where
13275 D: serde::Deserializer<'de>,
13276 {
13277 const FIELDS: &[&str] = &[
13278 "catalog_version",
13279 "catalogVersion",
13280 "hummock_version_id",
13281 "hummockVersionId",
13282 ];
13283
13284 #[allow(clippy::enum_variant_names)]
13285 enum GeneratedField {
13286 CatalogVersion,
13287 HummockVersionId,
13288 }
13289 impl<'de> serde::Deserialize<'de> for GeneratedField {
13290 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13291 where
13292 D: serde::Deserializer<'de>,
13293 {
13294 struct GeneratedVisitor;
13295
13296 impl serde::de::Visitor<'_> for GeneratedVisitor {
13297 type Value = GeneratedField;
13298
13299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13300 write!(formatter, "expected one of: {:?}", &FIELDS)
13301 }
13302
13303 #[allow(unused_variables)]
13304 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13305 where
13306 E: serde::de::Error,
13307 {
13308 match value {
13309 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13310 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
13311 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13312 }
13313 }
13314 }
13315 deserializer.deserialize_identifier(GeneratedVisitor)
13316 }
13317 }
13318 struct GeneratedVisitor;
13319 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13320 type Value = WaitVersion;
13321
13322 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13323 formatter.write_str("struct ddl_service.WaitVersion")
13324 }
13325
13326 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
13327 where
13328 V: serde::de::MapAccess<'de>,
13329 {
13330 let mut catalog_version__ = None;
13331 let mut hummock_version_id__ = None;
13332 while let Some(k) = map_.next_key()? {
13333 match k {
13334 GeneratedField::CatalogVersion => {
13335 if catalog_version__.is_some() {
13336 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13337 }
13338 catalog_version__ =
13339 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13340 ;
13341 }
13342 GeneratedField::HummockVersionId => {
13343 if hummock_version_id__.is_some() {
13344 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
13345 }
13346 hummock_version_id__ =
13347 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13348 ;
13349 }
13350 }
13351 }
13352 Ok(WaitVersion {
13353 catalog_version: catalog_version__.unwrap_or_default(),
13354 hummock_version_id: hummock_version_id__.unwrap_or_default(),
13355 })
13356 }
13357 }
13358 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
13359 }
13360}