1#![allow(clippy::useless_conversion)]
2use crate::ddl_service::*;
3impl serde::Serialize for AlterBackfillParallelismRequest {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.table_id != 0 {
12 len += 1;
13 }
14 if self.parallelism.is_some() {
15 len += 1;
16 }
17 if self.deferred {
18 len += 1;
19 }
20 if self.adaptive_parallelism_strategy.is_some() {
21 len += 1;
22 }
23 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismRequest", len)?;
24 if self.table_id != 0 {
25 struct_ser.serialize_field("tableId", &self.table_id)?;
26 }
27 if let Some(v) = self.parallelism.as_ref() {
28 struct_ser.serialize_field("parallelism", v)?;
29 }
30 if self.deferred {
31 struct_ser.serialize_field("deferred", &self.deferred)?;
32 }
33 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
34 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
35 }
36 struct_ser.end()
37 }
38}
39impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismRequest {
40 #[allow(deprecated)]
41 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
42 where
43 D: serde::Deserializer<'de>,
44 {
45 const FIELDS: &[&str] = &[
46 "table_id",
47 "tableId",
48 "parallelism",
49 "deferred",
50 "adaptive_parallelism_strategy",
51 "adaptiveParallelismStrategy",
52 ];
53
54 #[allow(clippy::enum_variant_names)]
55 enum GeneratedField {
56 TableId,
57 Parallelism,
58 Deferred,
59 AdaptiveParallelismStrategy,
60 }
61 impl<'de> serde::Deserialize<'de> for GeneratedField {
62 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
63 where
64 D: serde::Deserializer<'de>,
65 {
66 struct GeneratedVisitor;
67
68 impl serde::de::Visitor<'_> for GeneratedVisitor {
69 type Value = GeneratedField;
70
71 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
72 write!(formatter, "expected one of: {:?}", &FIELDS)
73 }
74
75 #[allow(unused_variables)]
76 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
77 where
78 E: serde::de::Error,
79 {
80 match value {
81 "tableId" | "table_id" => Ok(GeneratedField::TableId),
82 "parallelism" => Ok(GeneratedField::Parallelism),
83 "deferred" => Ok(GeneratedField::Deferred),
84 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
85 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
86 }
87 }
88 }
89 deserializer.deserialize_identifier(GeneratedVisitor)
90 }
91 }
92 struct GeneratedVisitor;
93 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
94 type Value = AlterBackfillParallelismRequest;
95
96 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
97 formatter.write_str("struct ddl_service.AlterBackfillParallelismRequest")
98 }
99
100 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismRequest, V::Error>
101 where
102 V: serde::de::MapAccess<'de>,
103 {
104 let mut table_id__ = None;
105 let mut parallelism__ = None;
106 let mut deferred__ = None;
107 let mut adaptive_parallelism_strategy__ = None;
108 while let Some(k) = map_.next_key()? {
109 match k {
110 GeneratedField::TableId => {
111 if table_id__.is_some() {
112 return Err(serde::de::Error::duplicate_field("tableId"));
113 }
114 table_id__ =
115 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
116 ;
117 }
118 GeneratedField::Parallelism => {
119 if parallelism__.is_some() {
120 return Err(serde::de::Error::duplicate_field("parallelism"));
121 }
122 parallelism__ = map_.next_value()?;
123 }
124 GeneratedField::Deferred => {
125 if deferred__.is_some() {
126 return Err(serde::de::Error::duplicate_field("deferred"));
127 }
128 deferred__ = Some(map_.next_value()?);
129 }
130 GeneratedField::AdaptiveParallelismStrategy => {
131 if adaptive_parallelism_strategy__.is_some() {
132 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
133 }
134 adaptive_parallelism_strategy__ = map_.next_value()?;
135 }
136 }
137 }
138 Ok(AlterBackfillParallelismRequest {
139 table_id: table_id__.unwrap_or_default(),
140 parallelism: parallelism__,
141 deferred: deferred__.unwrap_or_default(),
142 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
143 })
144 }
145 }
146 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismRequest", FIELDS, GeneratedVisitor)
147 }
148}
149impl serde::Serialize for AlterBackfillParallelismResponse {
150 #[allow(deprecated)]
151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
152 where
153 S: serde::Serializer,
154 {
155 use serde::ser::SerializeStruct;
156 let len = 0;
157 let struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismResponse", len)?;
158 struct_ser.end()
159 }
160}
161impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismResponse {
162 #[allow(deprecated)]
163 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
164 where
165 D: serde::Deserializer<'de>,
166 {
167 const FIELDS: &[&str] = &[
168 ];
169
170 #[allow(clippy::enum_variant_names)]
171 enum GeneratedField {
172 }
173 impl<'de> serde::Deserialize<'de> for GeneratedField {
174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
175 where
176 D: serde::Deserializer<'de>,
177 {
178 struct GeneratedVisitor;
179
180 impl serde::de::Visitor<'_> for GeneratedVisitor {
181 type Value = GeneratedField;
182
183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
184 write!(formatter, "expected one of: {:?}", &FIELDS)
185 }
186
187 #[allow(unused_variables)]
188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
189 where
190 E: serde::de::Error,
191 {
192 Err(serde::de::Error::unknown_field(value, FIELDS))
193 }
194 }
195 deserializer.deserialize_identifier(GeneratedVisitor)
196 }
197 }
198 struct GeneratedVisitor;
199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
200 type Value = AlterBackfillParallelismResponse;
201
202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
203 formatter.write_str("struct ddl_service.AlterBackfillParallelismResponse")
204 }
205
206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismResponse, V::Error>
207 where
208 V: serde::de::MapAccess<'de>,
209 {
210 while map_.next_key::<GeneratedField>()?.is_some() {
211 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
212 }
213 Ok(AlterBackfillParallelismResponse {
214 })
215 }
216 }
217 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismResponse", FIELDS, GeneratedVisitor)
218 }
219}
220impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
221 #[allow(deprecated)]
222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
223 where
224 S: serde::Serializer,
225 {
226 use serde::ser::SerializeStruct;
227 let mut len = 0;
228 if self.table_id != 0 {
229 len += 1;
230 }
231 if self.parallelism.is_some() {
232 len += 1;
233 }
234 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
235 if self.table_id != 0 {
236 struct_ser.serialize_field("tableId", &self.table_id)?;
237 }
238 if let Some(v) = self.parallelism.as_ref() {
239 struct_ser.serialize_field("parallelism", v)?;
240 }
241 struct_ser.end()
242 }
243}
244impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
245 #[allow(deprecated)]
246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
247 where
248 D: serde::Deserializer<'de>,
249 {
250 const FIELDS: &[&str] = &[
251 "table_id",
252 "tableId",
253 "parallelism",
254 ];
255
256 #[allow(clippy::enum_variant_names)]
257 enum GeneratedField {
258 TableId,
259 Parallelism,
260 }
261 impl<'de> serde::Deserialize<'de> for GeneratedField {
262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
263 where
264 D: serde::Deserializer<'de>,
265 {
266 struct GeneratedVisitor;
267
268 impl serde::de::Visitor<'_> for GeneratedVisitor {
269 type Value = GeneratedField;
270
271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 write!(formatter, "expected one of: {:?}", &FIELDS)
273 }
274
275 #[allow(unused_variables)]
276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
277 where
278 E: serde::de::Error,
279 {
280 match value {
281 "tableId" | "table_id" => Ok(GeneratedField::TableId),
282 "parallelism" => Ok(GeneratedField::Parallelism),
283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
284 }
285 }
286 }
287 deserializer.deserialize_identifier(GeneratedVisitor)
288 }
289 }
290 struct GeneratedVisitor;
291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
292 type Value = AlterCdcTableBackfillParallelismRequest;
293
294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
295 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
296 }
297
298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
299 where
300 V: serde::de::MapAccess<'de>,
301 {
302 let mut table_id__ = None;
303 let mut parallelism__ = None;
304 while let Some(k) = map_.next_key()? {
305 match k {
306 GeneratedField::TableId => {
307 if table_id__.is_some() {
308 return Err(serde::de::Error::duplicate_field("tableId"));
309 }
310 table_id__ =
311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
312 ;
313 }
314 GeneratedField::Parallelism => {
315 if parallelism__.is_some() {
316 return Err(serde::de::Error::duplicate_field("parallelism"));
317 }
318 parallelism__ = map_.next_value()?;
319 }
320 }
321 }
322 Ok(AlterCdcTableBackfillParallelismRequest {
323 table_id: table_id__.unwrap_or_default(),
324 parallelism: parallelism__,
325 })
326 }
327 }
328 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
329 }
330}
331impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
332 #[allow(deprecated)]
333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334 where
335 S: serde::Serializer,
336 {
337 use serde::ser::SerializeStruct;
338 let len = 0;
339 let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
340 struct_ser.end()
341 }
342}
343impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
344 #[allow(deprecated)]
345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
346 where
347 D: serde::Deserializer<'de>,
348 {
349 const FIELDS: &[&str] = &[
350 ];
351
352 #[allow(clippy::enum_variant_names)]
353 enum GeneratedField {
354 }
355 impl<'de> serde::Deserialize<'de> for GeneratedField {
356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
357 where
358 D: serde::Deserializer<'de>,
359 {
360 struct GeneratedVisitor;
361
362 impl serde::de::Visitor<'_> for GeneratedVisitor {
363 type Value = GeneratedField;
364
365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
366 write!(formatter, "expected one of: {:?}", &FIELDS)
367 }
368
369 #[allow(unused_variables)]
370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
371 where
372 E: serde::de::Error,
373 {
374 Err(serde::de::Error::unknown_field(value, FIELDS))
375 }
376 }
377 deserializer.deserialize_identifier(GeneratedVisitor)
378 }
379 }
380 struct GeneratedVisitor;
381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
382 type Value = AlterCdcTableBackfillParallelismResponse;
383
384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
385 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
386 }
387
388 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
389 where
390 V: serde::de::MapAccess<'de>,
391 {
392 while map_.next_key::<GeneratedField>()?.is_some() {
393 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
394 }
395 Ok(AlterCdcTableBackfillParallelismResponse {
396 })
397 }
398 }
399 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
400 }
401}
402impl serde::Serialize for AlterDatabaseParamRequest {
403 #[allow(deprecated)]
404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
405 where
406 S: serde::Serializer,
407 {
408 use serde::ser::SerializeStruct;
409 let mut len = 0;
410 if self.database_id != 0 {
411 len += 1;
412 }
413 if self.param.is_some() {
414 len += 1;
415 }
416 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
417 if self.database_id != 0 {
418 struct_ser.serialize_field("databaseId", &self.database_id)?;
419 }
420 if let Some(v) = self.param.as_ref() {
421 match v {
422 alter_database_param_request::Param::BarrierIntervalMs(v) => {
423 struct_ser.serialize_field("barrierIntervalMs", v)?;
424 }
425 alter_database_param_request::Param::CheckpointFrequency(v) => {
426 struct_ser.serialize_field("checkpointFrequency", v)?;
427 }
428 }
429 }
430 struct_ser.end()
431 }
432}
433impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
434 #[allow(deprecated)]
435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
436 where
437 D: serde::Deserializer<'de>,
438 {
439 const FIELDS: &[&str] = &[
440 "database_id",
441 "databaseId",
442 "barrier_interval_ms",
443 "barrierIntervalMs",
444 "checkpoint_frequency",
445 "checkpointFrequency",
446 ];
447
448 #[allow(clippy::enum_variant_names)]
449 enum GeneratedField {
450 DatabaseId,
451 BarrierIntervalMs,
452 CheckpointFrequency,
453 }
454 impl<'de> serde::Deserialize<'de> for GeneratedField {
455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
456 where
457 D: serde::Deserializer<'de>,
458 {
459 struct GeneratedVisitor;
460
461 impl serde::de::Visitor<'_> for GeneratedVisitor {
462 type Value = GeneratedField;
463
464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
465 write!(formatter, "expected one of: {:?}", &FIELDS)
466 }
467
468 #[allow(unused_variables)]
469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
470 where
471 E: serde::de::Error,
472 {
473 match value {
474 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
475 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
476 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
478 }
479 }
480 }
481 deserializer.deserialize_identifier(GeneratedVisitor)
482 }
483 }
484 struct GeneratedVisitor;
485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
486 type Value = AlterDatabaseParamRequest;
487
488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
489 formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
490 }
491
492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
493 where
494 V: serde::de::MapAccess<'de>,
495 {
496 let mut database_id__ = None;
497 let mut param__ = None;
498 while let Some(k) = map_.next_key()? {
499 match k {
500 GeneratedField::DatabaseId => {
501 if database_id__.is_some() {
502 return Err(serde::de::Error::duplicate_field("databaseId"));
503 }
504 database_id__ =
505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
506 ;
507 }
508 GeneratedField::BarrierIntervalMs => {
509 if param__.is_some() {
510 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
511 }
512 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
513;
514 }
515 GeneratedField::CheckpointFrequency => {
516 if param__.is_some() {
517 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
518 }
519 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
520;
521 }
522 }
523 }
524 Ok(AlterDatabaseParamRequest {
525 database_id: database_id__.unwrap_or_default(),
526 param: param__,
527 })
528 }
529 }
530 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
531 }
532}
533impl serde::Serialize for AlterDatabaseParamResponse {
534 #[allow(deprecated)]
535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
536 where
537 S: serde::Serializer,
538 {
539 use serde::ser::SerializeStruct;
540 let mut len = 0;
541 if self.status.is_some() {
542 len += 1;
543 }
544 if self.version.is_some() {
545 len += 1;
546 }
547 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
548 if let Some(v) = self.status.as_ref() {
549 struct_ser.serialize_field("status", v)?;
550 }
551 if let Some(v) = self.version.as_ref() {
552 struct_ser.serialize_field("version", v)?;
553 }
554 struct_ser.end()
555 }
556}
557impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
558 #[allow(deprecated)]
559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
560 where
561 D: serde::Deserializer<'de>,
562 {
563 const FIELDS: &[&str] = &[
564 "status",
565 "version",
566 ];
567
568 #[allow(clippy::enum_variant_names)]
569 enum GeneratedField {
570 Status,
571 Version,
572 }
573 impl<'de> serde::Deserialize<'de> for GeneratedField {
574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
575 where
576 D: serde::Deserializer<'de>,
577 {
578 struct GeneratedVisitor;
579
580 impl serde::de::Visitor<'_> for GeneratedVisitor {
581 type Value = GeneratedField;
582
583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
584 write!(formatter, "expected one of: {:?}", &FIELDS)
585 }
586
587 #[allow(unused_variables)]
588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
589 where
590 E: serde::de::Error,
591 {
592 match value {
593 "status" => Ok(GeneratedField::Status),
594 "version" => Ok(GeneratedField::Version),
595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
596 }
597 }
598 }
599 deserializer.deserialize_identifier(GeneratedVisitor)
600 }
601 }
602 struct GeneratedVisitor;
603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
604 type Value = AlterDatabaseParamResponse;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
608 }
609
610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
611 where
612 V: serde::de::MapAccess<'de>,
613 {
614 let mut status__ = None;
615 let mut version__ = None;
616 while let Some(k) = map_.next_key()? {
617 match k {
618 GeneratedField::Status => {
619 if status__.is_some() {
620 return Err(serde::de::Error::duplicate_field("status"));
621 }
622 status__ = map_.next_value()?;
623 }
624 GeneratedField::Version => {
625 if version__.is_some() {
626 return Err(serde::de::Error::duplicate_field("version"));
627 }
628 version__ = map_.next_value()?;
629 }
630 }
631 }
632 Ok(AlterDatabaseParamResponse {
633 status: status__,
634 version: version__,
635 })
636 }
637 }
638 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
639 }
640}
641impl serde::Serialize for AlterFragmentParallelismRequest {
642 #[allow(deprecated)]
643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
644 where
645 S: serde::Serializer,
646 {
647 use serde::ser::SerializeStruct;
648 let mut len = 0;
649 if !self.fragment_ids.is_empty() {
650 len += 1;
651 }
652 if self.parallelism.is_some() {
653 len += 1;
654 }
655 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismRequest", len)?;
656 if !self.fragment_ids.is_empty() {
657 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
658 }
659 if let Some(v) = self.parallelism.as_ref() {
660 struct_ser.serialize_field("parallelism", v)?;
661 }
662 struct_ser.end()
663 }
664}
665impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismRequest {
666 #[allow(deprecated)]
667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
668 where
669 D: serde::Deserializer<'de>,
670 {
671 const FIELDS: &[&str] = &[
672 "fragment_ids",
673 "fragmentIds",
674 "parallelism",
675 ];
676
677 #[allow(clippy::enum_variant_names)]
678 enum GeneratedField {
679 FragmentIds,
680 Parallelism,
681 }
682 impl<'de> serde::Deserialize<'de> for GeneratedField {
683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
684 where
685 D: serde::Deserializer<'de>,
686 {
687 struct GeneratedVisitor;
688
689 impl serde::de::Visitor<'_> for GeneratedVisitor {
690 type Value = GeneratedField;
691
692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
693 write!(formatter, "expected one of: {:?}", &FIELDS)
694 }
695
696 #[allow(unused_variables)]
697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
698 where
699 E: serde::de::Error,
700 {
701 match value {
702 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
703 "parallelism" => Ok(GeneratedField::Parallelism),
704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
705 }
706 }
707 }
708 deserializer.deserialize_identifier(GeneratedVisitor)
709 }
710 }
711 struct GeneratedVisitor;
712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
713 type Value = AlterFragmentParallelismRequest;
714
715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
716 formatter.write_str("struct ddl_service.AlterFragmentParallelismRequest")
717 }
718
719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismRequest, V::Error>
720 where
721 V: serde::de::MapAccess<'de>,
722 {
723 let mut fragment_ids__ = None;
724 let mut parallelism__ = None;
725 while let Some(k) = map_.next_key()? {
726 match k {
727 GeneratedField::FragmentIds => {
728 if fragment_ids__.is_some() {
729 return Err(serde::de::Error::duplicate_field("fragmentIds"));
730 }
731 fragment_ids__ =
732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
733 .into_iter().map(|x| x.0).collect())
734 ;
735 }
736 GeneratedField::Parallelism => {
737 if parallelism__.is_some() {
738 return Err(serde::de::Error::duplicate_field("parallelism"));
739 }
740 parallelism__ = map_.next_value()?;
741 }
742 }
743 }
744 Ok(AlterFragmentParallelismRequest {
745 fragment_ids: fragment_ids__.unwrap_or_default(),
746 parallelism: parallelism__,
747 })
748 }
749 }
750 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismRequest", FIELDS, GeneratedVisitor)
751 }
752}
753impl serde::Serialize for AlterFragmentParallelismResponse {
754 #[allow(deprecated)]
755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
756 where
757 S: serde::Serializer,
758 {
759 use serde::ser::SerializeStruct;
760 let len = 0;
761 let struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismResponse", len)?;
762 struct_ser.end()
763 }
764}
765impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismResponse {
766 #[allow(deprecated)]
767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
768 where
769 D: serde::Deserializer<'de>,
770 {
771 const FIELDS: &[&str] = &[
772 ];
773
774 #[allow(clippy::enum_variant_names)]
775 enum GeneratedField {
776 }
777 impl<'de> serde::Deserialize<'de> for GeneratedField {
778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
779 where
780 D: serde::Deserializer<'de>,
781 {
782 struct GeneratedVisitor;
783
784 impl serde::de::Visitor<'_> for GeneratedVisitor {
785 type Value = GeneratedField;
786
787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
788 write!(formatter, "expected one of: {:?}", &FIELDS)
789 }
790
791 #[allow(unused_variables)]
792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
793 where
794 E: serde::de::Error,
795 {
796 Err(serde::de::Error::unknown_field(value, FIELDS))
797 }
798 }
799 deserializer.deserialize_identifier(GeneratedVisitor)
800 }
801 }
802 struct GeneratedVisitor;
803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
804 type Value = AlterFragmentParallelismResponse;
805
806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
807 formatter.write_str("struct ddl_service.AlterFragmentParallelismResponse")
808 }
809
810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismResponse, V::Error>
811 where
812 V: serde::de::MapAccess<'de>,
813 {
814 while map_.next_key::<GeneratedField>()?.is_some() {
815 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
816 }
817 Ok(AlterFragmentParallelismResponse {
818 })
819 }
820 }
821 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismResponse", FIELDS, GeneratedVisitor)
822 }
823}
824impl serde::Serialize for AlterNameRequest {
825 #[allow(deprecated)]
826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
827 where
828 S: serde::Serializer,
829 {
830 use serde::ser::SerializeStruct;
831 let mut len = 0;
832 if !self.new_name.is_empty() {
833 len += 1;
834 }
835 if self.object.is_some() {
836 len += 1;
837 }
838 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
839 if !self.new_name.is_empty() {
840 struct_ser.serialize_field("newName", &self.new_name)?;
841 }
842 if let Some(v) = self.object.as_ref() {
843 match v {
844 alter_name_request::Object::TableId(v) => {
845 struct_ser.serialize_field("tableId", v)?;
846 }
847 alter_name_request::Object::ViewId(v) => {
848 struct_ser.serialize_field("viewId", v)?;
849 }
850 alter_name_request::Object::IndexId(v) => {
851 struct_ser.serialize_field("indexId", v)?;
852 }
853 alter_name_request::Object::SinkId(v) => {
854 struct_ser.serialize_field("sinkId", v)?;
855 }
856 alter_name_request::Object::SourceId(v) => {
857 struct_ser.serialize_field("sourceId", v)?;
858 }
859 alter_name_request::Object::SchemaId(v) => {
860 struct_ser.serialize_field("schemaId", v)?;
861 }
862 alter_name_request::Object::DatabaseId(v) => {
863 struct_ser.serialize_field("databaseId", v)?;
864 }
865 alter_name_request::Object::SubscriptionId(v) => {
866 struct_ser.serialize_field("subscriptionId", v)?;
867 }
868 }
869 }
870 struct_ser.end()
871 }
872}
873impl<'de> serde::Deserialize<'de> for AlterNameRequest {
874 #[allow(deprecated)]
875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
876 where
877 D: serde::Deserializer<'de>,
878 {
879 const FIELDS: &[&str] = &[
880 "new_name",
881 "newName",
882 "table_id",
883 "tableId",
884 "view_id",
885 "viewId",
886 "index_id",
887 "indexId",
888 "sink_id",
889 "sinkId",
890 "source_id",
891 "sourceId",
892 "schema_id",
893 "schemaId",
894 "database_id",
895 "databaseId",
896 "subscription_id",
897 "subscriptionId",
898 ];
899
900 #[allow(clippy::enum_variant_names)]
901 enum GeneratedField {
902 NewName,
903 TableId,
904 ViewId,
905 IndexId,
906 SinkId,
907 SourceId,
908 SchemaId,
909 DatabaseId,
910 SubscriptionId,
911 }
912 impl<'de> serde::Deserialize<'de> for GeneratedField {
913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
914 where
915 D: serde::Deserializer<'de>,
916 {
917 struct GeneratedVisitor;
918
919 impl serde::de::Visitor<'_> for GeneratedVisitor {
920 type Value = GeneratedField;
921
922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
923 write!(formatter, "expected one of: {:?}", &FIELDS)
924 }
925
926 #[allow(unused_variables)]
927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
928 where
929 E: serde::de::Error,
930 {
931 match value {
932 "newName" | "new_name" => Ok(GeneratedField::NewName),
933 "tableId" | "table_id" => Ok(GeneratedField::TableId),
934 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
935 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
936 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
937 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
938 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
939 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
940 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
942 }
943 }
944 }
945 deserializer.deserialize_identifier(GeneratedVisitor)
946 }
947 }
948 struct GeneratedVisitor;
949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
950 type Value = AlterNameRequest;
951
952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
953 formatter.write_str("struct ddl_service.AlterNameRequest")
954 }
955
956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
957 where
958 V: serde::de::MapAccess<'de>,
959 {
960 let mut new_name__ = None;
961 let mut object__ = None;
962 while let Some(k) = map_.next_key()? {
963 match k {
964 GeneratedField::NewName => {
965 if new_name__.is_some() {
966 return Err(serde::de::Error::duplicate_field("newName"));
967 }
968 new_name__ = Some(map_.next_value()?);
969 }
970 GeneratedField::TableId => {
971 if object__.is_some() {
972 return Err(serde::de::Error::duplicate_field("tableId"));
973 }
974 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
975 }
976 GeneratedField::ViewId => {
977 if object__.is_some() {
978 return Err(serde::de::Error::duplicate_field("viewId"));
979 }
980 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
981 }
982 GeneratedField::IndexId => {
983 if object__.is_some() {
984 return Err(serde::de::Error::duplicate_field("indexId"));
985 }
986 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
987 }
988 GeneratedField::SinkId => {
989 if object__.is_some() {
990 return Err(serde::de::Error::duplicate_field("sinkId"));
991 }
992 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
993 }
994 GeneratedField::SourceId => {
995 if object__.is_some() {
996 return Err(serde::de::Error::duplicate_field("sourceId"));
997 }
998 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
999 }
1000 GeneratedField::SchemaId => {
1001 if object__.is_some() {
1002 return Err(serde::de::Error::duplicate_field("schemaId"));
1003 }
1004 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
1005 }
1006 GeneratedField::DatabaseId => {
1007 if object__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("databaseId"));
1009 }
1010 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
1011 }
1012 GeneratedField::SubscriptionId => {
1013 if object__.is_some() {
1014 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1015 }
1016 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
1017 }
1018 }
1019 }
1020 Ok(AlterNameRequest {
1021 new_name: new_name__.unwrap_or_default(),
1022 object: object__,
1023 })
1024 }
1025 }
1026 deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
1027 }
1028}
1029impl serde::Serialize for AlterNameResponse {
1030 #[allow(deprecated)]
1031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1032 where
1033 S: serde::Serializer,
1034 {
1035 use serde::ser::SerializeStruct;
1036 let mut len = 0;
1037 if self.status.is_some() {
1038 len += 1;
1039 }
1040 if self.version.is_some() {
1041 len += 1;
1042 }
1043 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
1044 if let Some(v) = self.status.as_ref() {
1045 struct_ser.serialize_field("status", v)?;
1046 }
1047 if let Some(v) = self.version.as_ref() {
1048 struct_ser.serialize_field("version", v)?;
1049 }
1050 struct_ser.end()
1051 }
1052}
1053impl<'de> serde::Deserialize<'de> for AlterNameResponse {
1054 #[allow(deprecated)]
1055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1056 where
1057 D: serde::Deserializer<'de>,
1058 {
1059 const FIELDS: &[&str] = &[
1060 "status",
1061 "version",
1062 ];
1063
1064 #[allow(clippy::enum_variant_names)]
1065 enum GeneratedField {
1066 Status,
1067 Version,
1068 }
1069 impl<'de> serde::Deserialize<'de> for GeneratedField {
1070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1071 where
1072 D: serde::Deserializer<'de>,
1073 {
1074 struct GeneratedVisitor;
1075
1076 impl serde::de::Visitor<'_> for GeneratedVisitor {
1077 type Value = GeneratedField;
1078
1079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1080 write!(formatter, "expected one of: {:?}", &FIELDS)
1081 }
1082
1083 #[allow(unused_variables)]
1084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1085 where
1086 E: serde::de::Error,
1087 {
1088 match value {
1089 "status" => Ok(GeneratedField::Status),
1090 "version" => Ok(GeneratedField::Version),
1091 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1092 }
1093 }
1094 }
1095 deserializer.deserialize_identifier(GeneratedVisitor)
1096 }
1097 }
1098 struct GeneratedVisitor;
1099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1100 type Value = AlterNameResponse;
1101
1102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1103 formatter.write_str("struct ddl_service.AlterNameResponse")
1104 }
1105
1106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
1107 where
1108 V: serde::de::MapAccess<'de>,
1109 {
1110 let mut status__ = None;
1111 let mut version__ = None;
1112 while let Some(k) = map_.next_key()? {
1113 match k {
1114 GeneratedField::Status => {
1115 if status__.is_some() {
1116 return Err(serde::de::Error::duplicate_field("status"));
1117 }
1118 status__ = map_.next_value()?;
1119 }
1120 GeneratedField::Version => {
1121 if version__.is_some() {
1122 return Err(serde::de::Error::duplicate_field("version"));
1123 }
1124 version__ = map_.next_value()?;
1125 }
1126 }
1127 }
1128 Ok(AlterNameResponse {
1129 status: status__,
1130 version: version__,
1131 })
1132 }
1133 }
1134 deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
1135 }
1136}
1137impl serde::Serialize for AlterOwnerRequest {
1138 #[allow(deprecated)]
1139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1140 where
1141 S: serde::Serializer,
1142 {
1143 use serde::ser::SerializeStruct;
1144 let mut len = 0;
1145 if self.owner_id != 0 {
1146 len += 1;
1147 }
1148 if self.object.is_some() {
1149 len += 1;
1150 }
1151 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
1152 if self.owner_id != 0 {
1153 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1154 }
1155 if let Some(v) = self.object.as_ref() {
1156 match v {
1157 alter_owner_request::Object::TableId(v) => {
1158 struct_ser.serialize_field("tableId", v)?;
1159 }
1160 alter_owner_request::Object::ViewId(v) => {
1161 struct_ser.serialize_field("viewId", v)?;
1162 }
1163 alter_owner_request::Object::SourceId(v) => {
1164 struct_ser.serialize_field("sourceId", v)?;
1165 }
1166 alter_owner_request::Object::SinkId(v) => {
1167 struct_ser.serialize_field("sinkId", v)?;
1168 }
1169 alter_owner_request::Object::SchemaId(v) => {
1170 struct_ser.serialize_field("schemaId", v)?;
1171 }
1172 alter_owner_request::Object::DatabaseId(v) => {
1173 struct_ser.serialize_field("databaseId", v)?;
1174 }
1175 alter_owner_request::Object::SubscriptionId(v) => {
1176 struct_ser.serialize_field("subscriptionId", v)?;
1177 }
1178 alter_owner_request::Object::ConnectionId(v) => {
1179 struct_ser.serialize_field("connectionId", v)?;
1180 }
1181 alter_owner_request::Object::SecretId(v) => {
1182 struct_ser.serialize_field("secretId", v)?;
1183 }
1184 alter_owner_request::Object::FunctionId(v) => {
1185 struct_ser.serialize_field("functionId", v)?;
1186 }
1187 }
1188 }
1189 struct_ser.end()
1190 }
1191}
1192impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
1193 #[allow(deprecated)]
1194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1195 where
1196 D: serde::Deserializer<'de>,
1197 {
1198 const FIELDS: &[&str] = &[
1199 "owner_id",
1200 "ownerId",
1201 "table_id",
1202 "tableId",
1203 "view_id",
1204 "viewId",
1205 "source_id",
1206 "sourceId",
1207 "sink_id",
1208 "sinkId",
1209 "schema_id",
1210 "schemaId",
1211 "database_id",
1212 "databaseId",
1213 "subscription_id",
1214 "subscriptionId",
1215 "connection_id",
1216 "connectionId",
1217 "secret_id",
1218 "secretId",
1219 "function_id",
1220 "functionId",
1221 ];
1222
1223 #[allow(clippy::enum_variant_names)]
1224 enum GeneratedField {
1225 OwnerId,
1226 TableId,
1227 ViewId,
1228 SourceId,
1229 SinkId,
1230 SchemaId,
1231 DatabaseId,
1232 SubscriptionId,
1233 ConnectionId,
1234 SecretId,
1235 FunctionId,
1236 }
1237 impl<'de> serde::Deserialize<'de> for GeneratedField {
1238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1239 where
1240 D: serde::Deserializer<'de>,
1241 {
1242 struct GeneratedVisitor;
1243
1244 impl serde::de::Visitor<'_> for GeneratedVisitor {
1245 type Value = GeneratedField;
1246
1247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1248 write!(formatter, "expected one of: {:?}", &FIELDS)
1249 }
1250
1251 #[allow(unused_variables)]
1252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1253 where
1254 E: serde::de::Error,
1255 {
1256 match value {
1257 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1258 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1259 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1260 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1261 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1262 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1263 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1264 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1265 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1266 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1267 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1269 }
1270 }
1271 }
1272 deserializer.deserialize_identifier(GeneratedVisitor)
1273 }
1274 }
1275 struct GeneratedVisitor;
1276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1277 type Value = AlterOwnerRequest;
1278
1279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1280 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1281 }
1282
1283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1284 where
1285 V: serde::de::MapAccess<'de>,
1286 {
1287 let mut owner_id__ = None;
1288 let mut object__ = None;
1289 while let Some(k) = map_.next_key()? {
1290 match k {
1291 GeneratedField::OwnerId => {
1292 if owner_id__.is_some() {
1293 return Err(serde::de::Error::duplicate_field("ownerId"));
1294 }
1295 owner_id__ =
1296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1297 ;
1298 }
1299 GeneratedField::TableId => {
1300 if object__.is_some() {
1301 return Err(serde::de::Error::duplicate_field("tableId"));
1302 }
1303 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1304 }
1305 GeneratedField::ViewId => {
1306 if object__.is_some() {
1307 return Err(serde::de::Error::duplicate_field("viewId"));
1308 }
1309 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1310 }
1311 GeneratedField::SourceId => {
1312 if object__.is_some() {
1313 return Err(serde::de::Error::duplicate_field("sourceId"));
1314 }
1315 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1316 }
1317 GeneratedField::SinkId => {
1318 if object__.is_some() {
1319 return Err(serde::de::Error::duplicate_field("sinkId"));
1320 }
1321 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1322 }
1323 GeneratedField::SchemaId => {
1324 if object__.is_some() {
1325 return Err(serde::de::Error::duplicate_field("schemaId"));
1326 }
1327 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1328 }
1329 GeneratedField::DatabaseId => {
1330 if object__.is_some() {
1331 return Err(serde::de::Error::duplicate_field("databaseId"));
1332 }
1333 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1334 }
1335 GeneratedField::SubscriptionId => {
1336 if object__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1338 }
1339 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1340 }
1341 GeneratedField::ConnectionId => {
1342 if object__.is_some() {
1343 return Err(serde::de::Error::duplicate_field("connectionId"));
1344 }
1345 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1346 }
1347 GeneratedField::SecretId => {
1348 if object__.is_some() {
1349 return Err(serde::de::Error::duplicate_field("secretId"));
1350 }
1351 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SecretId(x.0));
1352 }
1353 GeneratedField::FunctionId => {
1354 if object__.is_some() {
1355 return Err(serde::de::Error::duplicate_field("functionId"));
1356 }
1357 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::FunctionId(x.0));
1358 }
1359 }
1360 }
1361 Ok(AlterOwnerRequest {
1362 owner_id: owner_id__.unwrap_or_default(),
1363 object: object__,
1364 })
1365 }
1366 }
1367 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1368 }
1369}
1370impl serde::Serialize for AlterOwnerResponse {
1371 #[allow(deprecated)]
1372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1373 where
1374 S: serde::Serializer,
1375 {
1376 use serde::ser::SerializeStruct;
1377 let mut len = 0;
1378 if self.status.is_some() {
1379 len += 1;
1380 }
1381 if self.version.is_some() {
1382 len += 1;
1383 }
1384 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1385 if let Some(v) = self.status.as_ref() {
1386 struct_ser.serialize_field("status", v)?;
1387 }
1388 if let Some(v) = self.version.as_ref() {
1389 struct_ser.serialize_field("version", v)?;
1390 }
1391 struct_ser.end()
1392 }
1393}
1394impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1395 #[allow(deprecated)]
1396 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1397 where
1398 D: serde::Deserializer<'de>,
1399 {
1400 const FIELDS: &[&str] = &[
1401 "status",
1402 "version",
1403 ];
1404
1405 #[allow(clippy::enum_variant_names)]
1406 enum GeneratedField {
1407 Status,
1408 Version,
1409 }
1410 impl<'de> serde::Deserialize<'de> for GeneratedField {
1411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1412 where
1413 D: serde::Deserializer<'de>,
1414 {
1415 struct GeneratedVisitor;
1416
1417 impl serde::de::Visitor<'_> for GeneratedVisitor {
1418 type Value = GeneratedField;
1419
1420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1421 write!(formatter, "expected one of: {:?}", &FIELDS)
1422 }
1423
1424 #[allow(unused_variables)]
1425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1426 where
1427 E: serde::de::Error,
1428 {
1429 match value {
1430 "status" => Ok(GeneratedField::Status),
1431 "version" => Ok(GeneratedField::Version),
1432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1433 }
1434 }
1435 }
1436 deserializer.deserialize_identifier(GeneratedVisitor)
1437 }
1438 }
1439 struct GeneratedVisitor;
1440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1441 type Value = AlterOwnerResponse;
1442
1443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1444 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1445 }
1446
1447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1448 where
1449 V: serde::de::MapAccess<'de>,
1450 {
1451 let mut status__ = None;
1452 let mut version__ = None;
1453 while let Some(k) = map_.next_key()? {
1454 match k {
1455 GeneratedField::Status => {
1456 if status__.is_some() {
1457 return Err(serde::de::Error::duplicate_field("status"));
1458 }
1459 status__ = map_.next_value()?;
1460 }
1461 GeneratedField::Version => {
1462 if version__.is_some() {
1463 return Err(serde::de::Error::duplicate_field("version"));
1464 }
1465 version__ = map_.next_value()?;
1466 }
1467 }
1468 }
1469 Ok(AlterOwnerResponse {
1470 status: status__,
1471 version: version__,
1472 })
1473 }
1474 }
1475 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1476 }
1477}
1478impl serde::Serialize for AlterParallelismRequest {
1479 #[allow(deprecated)]
1480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1481 where
1482 S: serde::Serializer,
1483 {
1484 use serde::ser::SerializeStruct;
1485 let mut len = 0;
1486 if self.table_id != 0 {
1487 len += 1;
1488 }
1489 if self.parallelism.is_some() {
1490 len += 1;
1491 }
1492 if self.deferred {
1493 len += 1;
1494 }
1495 if self.adaptive_parallelism_strategy.is_some() {
1496 len += 1;
1497 }
1498 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1499 if self.table_id != 0 {
1500 struct_ser.serialize_field("tableId", &self.table_id)?;
1501 }
1502 if let Some(v) = self.parallelism.as_ref() {
1503 struct_ser.serialize_field("parallelism", v)?;
1504 }
1505 if self.deferred {
1506 struct_ser.serialize_field("deferred", &self.deferred)?;
1507 }
1508 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
1509 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
1510 }
1511 struct_ser.end()
1512 }
1513}
1514impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1515 #[allow(deprecated)]
1516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1517 where
1518 D: serde::Deserializer<'de>,
1519 {
1520 const FIELDS: &[&str] = &[
1521 "table_id",
1522 "tableId",
1523 "parallelism",
1524 "deferred",
1525 "adaptive_parallelism_strategy",
1526 "adaptiveParallelismStrategy",
1527 ];
1528
1529 #[allow(clippy::enum_variant_names)]
1530 enum GeneratedField {
1531 TableId,
1532 Parallelism,
1533 Deferred,
1534 AdaptiveParallelismStrategy,
1535 }
1536 impl<'de> serde::Deserialize<'de> for GeneratedField {
1537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1538 where
1539 D: serde::Deserializer<'de>,
1540 {
1541 struct GeneratedVisitor;
1542
1543 impl serde::de::Visitor<'_> for GeneratedVisitor {
1544 type Value = GeneratedField;
1545
1546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1547 write!(formatter, "expected one of: {:?}", &FIELDS)
1548 }
1549
1550 #[allow(unused_variables)]
1551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1552 where
1553 E: serde::de::Error,
1554 {
1555 match value {
1556 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1557 "parallelism" => Ok(GeneratedField::Parallelism),
1558 "deferred" => Ok(GeneratedField::Deferred),
1559 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
1560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1561 }
1562 }
1563 }
1564 deserializer.deserialize_identifier(GeneratedVisitor)
1565 }
1566 }
1567 struct GeneratedVisitor;
1568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1569 type Value = AlterParallelismRequest;
1570
1571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1572 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1573 }
1574
1575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1576 where
1577 V: serde::de::MapAccess<'de>,
1578 {
1579 let mut table_id__ = None;
1580 let mut parallelism__ = None;
1581 let mut deferred__ = None;
1582 let mut adaptive_parallelism_strategy__ = None;
1583 while let Some(k) = map_.next_key()? {
1584 match k {
1585 GeneratedField::TableId => {
1586 if table_id__.is_some() {
1587 return Err(serde::de::Error::duplicate_field("tableId"));
1588 }
1589 table_id__ =
1590 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1591 ;
1592 }
1593 GeneratedField::Parallelism => {
1594 if parallelism__.is_some() {
1595 return Err(serde::de::Error::duplicate_field("parallelism"));
1596 }
1597 parallelism__ = map_.next_value()?;
1598 }
1599 GeneratedField::Deferred => {
1600 if deferred__.is_some() {
1601 return Err(serde::de::Error::duplicate_field("deferred"));
1602 }
1603 deferred__ = Some(map_.next_value()?);
1604 }
1605 GeneratedField::AdaptiveParallelismStrategy => {
1606 if adaptive_parallelism_strategy__.is_some() {
1607 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
1608 }
1609 adaptive_parallelism_strategy__ = map_.next_value()?;
1610 }
1611 }
1612 }
1613 Ok(AlterParallelismRequest {
1614 table_id: table_id__.unwrap_or_default(),
1615 parallelism: parallelism__,
1616 deferred: deferred__.unwrap_or_default(),
1617 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
1618 })
1619 }
1620 }
1621 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1622 }
1623}
1624impl serde::Serialize for AlterParallelismResponse {
1625 #[allow(deprecated)]
1626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1627 where
1628 S: serde::Serializer,
1629 {
1630 use serde::ser::SerializeStruct;
1631 let len = 0;
1632 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1633 struct_ser.end()
1634 }
1635}
1636impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1637 #[allow(deprecated)]
1638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1639 where
1640 D: serde::Deserializer<'de>,
1641 {
1642 const FIELDS: &[&str] = &[
1643 ];
1644
1645 #[allow(clippy::enum_variant_names)]
1646 enum GeneratedField {
1647 }
1648 impl<'de> serde::Deserialize<'de> for GeneratedField {
1649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1650 where
1651 D: serde::Deserializer<'de>,
1652 {
1653 struct GeneratedVisitor;
1654
1655 impl serde::de::Visitor<'_> for GeneratedVisitor {
1656 type Value = GeneratedField;
1657
1658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1659 write!(formatter, "expected one of: {:?}", &FIELDS)
1660 }
1661
1662 #[allow(unused_variables)]
1663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1664 where
1665 E: serde::de::Error,
1666 {
1667 Err(serde::de::Error::unknown_field(value, FIELDS))
1668 }
1669 }
1670 deserializer.deserialize_identifier(GeneratedVisitor)
1671 }
1672 }
1673 struct GeneratedVisitor;
1674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1675 type Value = AlterParallelismResponse;
1676
1677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1678 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1679 }
1680
1681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1682 where
1683 V: serde::de::MapAccess<'de>,
1684 {
1685 while map_.next_key::<GeneratedField>()?.is_some() {
1686 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1687 }
1688 Ok(AlterParallelismResponse {
1689 })
1690 }
1691 }
1692 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1693 }
1694}
1695impl serde::Serialize for AlterResourceGroupRequest {
1696 #[allow(deprecated)]
1697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1698 where
1699 S: serde::Serializer,
1700 {
1701 use serde::ser::SerializeStruct;
1702 let mut len = 0;
1703 if self.table_id != 0 {
1704 len += 1;
1705 }
1706 if self.resource_group.is_some() {
1707 len += 1;
1708 }
1709 if self.deferred {
1710 len += 1;
1711 }
1712 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1713 if self.table_id != 0 {
1714 struct_ser.serialize_field("tableId", &self.table_id)?;
1715 }
1716 if let Some(v) = self.resource_group.as_ref() {
1717 struct_ser.serialize_field("resourceGroup", v)?;
1718 }
1719 if self.deferred {
1720 struct_ser.serialize_field("deferred", &self.deferred)?;
1721 }
1722 struct_ser.end()
1723 }
1724}
1725impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1726 #[allow(deprecated)]
1727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1728 where
1729 D: serde::Deserializer<'de>,
1730 {
1731 const FIELDS: &[&str] = &[
1732 "table_id",
1733 "tableId",
1734 "resource_group",
1735 "resourceGroup",
1736 "deferred",
1737 ];
1738
1739 #[allow(clippy::enum_variant_names)]
1740 enum GeneratedField {
1741 TableId,
1742 ResourceGroup,
1743 Deferred,
1744 }
1745 impl<'de> serde::Deserialize<'de> for GeneratedField {
1746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1747 where
1748 D: serde::Deserializer<'de>,
1749 {
1750 struct GeneratedVisitor;
1751
1752 impl serde::de::Visitor<'_> for GeneratedVisitor {
1753 type Value = GeneratedField;
1754
1755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1756 write!(formatter, "expected one of: {:?}", &FIELDS)
1757 }
1758
1759 #[allow(unused_variables)]
1760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1761 where
1762 E: serde::de::Error,
1763 {
1764 match value {
1765 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1766 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1767 "deferred" => Ok(GeneratedField::Deferred),
1768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1769 }
1770 }
1771 }
1772 deserializer.deserialize_identifier(GeneratedVisitor)
1773 }
1774 }
1775 struct GeneratedVisitor;
1776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1777 type Value = AlterResourceGroupRequest;
1778
1779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1780 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1781 }
1782
1783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1784 where
1785 V: serde::de::MapAccess<'de>,
1786 {
1787 let mut table_id__ = None;
1788 let mut resource_group__ = None;
1789 let mut deferred__ = None;
1790 while let Some(k) = map_.next_key()? {
1791 match k {
1792 GeneratedField::TableId => {
1793 if table_id__.is_some() {
1794 return Err(serde::de::Error::duplicate_field("tableId"));
1795 }
1796 table_id__ =
1797 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1798 ;
1799 }
1800 GeneratedField::ResourceGroup => {
1801 if resource_group__.is_some() {
1802 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1803 }
1804 resource_group__ = map_.next_value()?;
1805 }
1806 GeneratedField::Deferred => {
1807 if deferred__.is_some() {
1808 return Err(serde::de::Error::duplicate_field("deferred"));
1809 }
1810 deferred__ = Some(map_.next_value()?);
1811 }
1812 }
1813 }
1814 Ok(AlterResourceGroupRequest {
1815 table_id: table_id__.unwrap_or_default(),
1816 resource_group: resource_group__,
1817 deferred: deferred__.unwrap_or_default(),
1818 })
1819 }
1820 }
1821 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1822 }
1823}
1824impl serde::Serialize for AlterResourceGroupResponse {
1825 #[allow(deprecated)]
1826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1827 where
1828 S: serde::Serializer,
1829 {
1830 use serde::ser::SerializeStruct;
1831 let len = 0;
1832 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1833 struct_ser.end()
1834 }
1835}
1836impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1837 #[allow(deprecated)]
1838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1839 where
1840 D: serde::Deserializer<'de>,
1841 {
1842 const FIELDS: &[&str] = &[
1843 ];
1844
1845 #[allow(clippy::enum_variant_names)]
1846 enum GeneratedField {
1847 }
1848 impl<'de> serde::Deserialize<'de> for GeneratedField {
1849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1850 where
1851 D: serde::Deserializer<'de>,
1852 {
1853 struct GeneratedVisitor;
1854
1855 impl serde::de::Visitor<'_> for GeneratedVisitor {
1856 type Value = GeneratedField;
1857
1858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1859 write!(formatter, "expected one of: {:?}", &FIELDS)
1860 }
1861
1862 #[allow(unused_variables)]
1863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1864 where
1865 E: serde::de::Error,
1866 {
1867 Err(serde::de::Error::unknown_field(value, FIELDS))
1868 }
1869 }
1870 deserializer.deserialize_identifier(GeneratedVisitor)
1871 }
1872 }
1873 struct GeneratedVisitor;
1874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1875 type Value = AlterResourceGroupResponse;
1876
1877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1878 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1879 }
1880
1881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1882 where
1883 V: serde::de::MapAccess<'de>,
1884 {
1885 while map_.next_key::<GeneratedField>()?.is_some() {
1886 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1887 }
1888 Ok(AlterResourceGroupResponse {
1889 })
1890 }
1891 }
1892 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1893 }
1894}
1895impl serde::Serialize for AlterSecretRequest {
1896 #[allow(deprecated)]
1897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1898 where
1899 S: serde::Serializer,
1900 {
1901 use serde::ser::SerializeStruct;
1902 let mut len = 0;
1903 if self.secret_id != 0 {
1904 len += 1;
1905 }
1906 if !self.name.is_empty() {
1907 len += 1;
1908 }
1909 if !self.value.is_empty() {
1910 len += 1;
1911 }
1912 if self.database_id != 0 {
1913 len += 1;
1914 }
1915 if self.schema_id != 0 {
1916 len += 1;
1917 }
1918 if self.owner_id != 0 {
1919 len += 1;
1920 }
1921 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1922 if self.secret_id != 0 {
1923 struct_ser.serialize_field("secretId", &self.secret_id)?;
1924 }
1925 if !self.name.is_empty() {
1926 struct_ser.serialize_field("name", &self.name)?;
1927 }
1928 if !self.value.is_empty() {
1929 #[allow(clippy::needless_borrow)]
1930 #[allow(clippy::needless_borrows_for_generic_args)]
1931 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1932 }
1933 if self.database_id != 0 {
1934 struct_ser.serialize_field("databaseId", &self.database_id)?;
1935 }
1936 if self.schema_id != 0 {
1937 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1938 }
1939 if self.owner_id != 0 {
1940 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1941 }
1942 struct_ser.end()
1943 }
1944}
1945impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1946 #[allow(deprecated)]
1947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1948 where
1949 D: serde::Deserializer<'de>,
1950 {
1951 const FIELDS: &[&str] = &[
1952 "secret_id",
1953 "secretId",
1954 "name",
1955 "value",
1956 "database_id",
1957 "databaseId",
1958 "schema_id",
1959 "schemaId",
1960 "owner_id",
1961 "ownerId",
1962 ];
1963
1964 #[allow(clippy::enum_variant_names)]
1965 enum GeneratedField {
1966 SecretId,
1967 Name,
1968 Value,
1969 DatabaseId,
1970 SchemaId,
1971 OwnerId,
1972 }
1973 impl<'de> serde::Deserialize<'de> for GeneratedField {
1974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1975 where
1976 D: serde::Deserializer<'de>,
1977 {
1978 struct GeneratedVisitor;
1979
1980 impl serde::de::Visitor<'_> for GeneratedVisitor {
1981 type Value = GeneratedField;
1982
1983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1984 write!(formatter, "expected one of: {:?}", &FIELDS)
1985 }
1986
1987 #[allow(unused_variables)]
1988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1989 where
1990 E: serde::de::Error,
1991 {
1992 match value {
1993 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1994 "name" => Ok(GeneratedField::Name),
1995 "value" => Ok(GeneratedField::Value),
1996 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1997 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1998 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1999 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2000 }
2001 }
2002 }
2003 deserializer.deserialize_identifier(GeneratedVisitor)
2004 }
2005 }
2006 struct GeneratedVisitor;
2007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2008 type Value = AlterSecretRequest;
2009
2010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2011 formatter.write_str("struct ddl_service.AlterSecretRequest")
2012 }
2013
2014 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
2015 where
2016 V: serde::de::MapAccess<'de>,
2017 {
2018 let mut secret_id__ = None;
2019 let mut name__ = None;
2020 let mut value__ = None;
2021 let mut database_id__ = None;
2022 let mut schema_id__ = None;
2023 let mut owner_id__ = None;
2024 while let Some(k) = map_.next_key()? {
2025 match k {
2026 GeneratedField::SecretId => {
2027 if secret_id__.is_some() {
2028 return Err(serde::de::Error::duplicate_field("secretId"));
2029 }
2030 secret_id__ =
2031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2032 ;
2033 }
2034 GeneratedField::Name => {
2035 if name__.is_some() {
2036 return Err(serde::de::Error::duplicate_field("name"));
2037 }
2038 name__ = Some(map_.next_value()?);
2039 }
2040 GeneratedField::Value => {
2041 if value__.is_some() {
2042 return Err(serde::de::Error::duplicate_field("value"));
2043 }
2044 value__ =
2045 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2046 ;
2047 }
2048 GeneratedField::DatabaseId => {
2049 if database_id__.is_some() {
2050 return Err(serde::de::Error::duplicate_field("databaseId"));
2051 }
2052 database_id__ =
2053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2054 ;
2055 }
2056 GeneratedField::SchemaId => {
2057 if schema_id__.is_some() {
2058 return Err(serde::de::Error::duplicate_field("schemaId"));
2059 }
2060 schema_id__ =
2061 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2062 ;
2063 }
2064 GeneratedField::OwnerId => {
2065 if owner_id__.is_some() {
2066 return Err(serde::de::Error::duplicate_field("ownerId"));
2067 }
2068 owner_id__ =
2069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2070 ;
2071 }
2072 }
2073 }
2074 Ok(AlterSecretRequest {
2075 secret_id: secret_id__.unwrap_or_default(),
2076 name: name__.unwrap_or_default(),
2077 value: value__.unwrap_or_default(),
2078 database_id: database_id__.unwrap_or_default(),
2079 schema_id: schema_id__.unwrap_or_default(),
2080 owner_id: owner_id__.unwrap_or_default(),
2081 })
2082 }
2083 }
2084 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
2085 }
2086}
2087impl serde::Serialize for AlterSecretResponse {
2088 #[allow(deprecated)]
2089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2090 where
2091 S: serde::Serializer,
2092 {
2093 use serde::ser::SerializeStruct;
2094 let mut len = 0;
2095 if self.version.is_some() {
2096 len += 1;
2097 }
2098 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
2099 if let Some(v) = self.version.as_ref() {
2100 struct_ser.serialize_field("version", v)?;
2101 }
2102 struct_ser.end()
2103 }
2104}
2105impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
2106 #[allow(deprecated)]
2107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2108 where
2109 D: serde::Deserializer<'de>,
2110 {
2111 const FIELDS: &[&str] = &[
2112 "version",
2113 ];
2114
2115 #[allow(clippy::enum_variant_names)]
2116 enum GeneratedField {
2117 Version,
2118 }
2119 impl<'de> serde::Deserialize<'de> for GeneratedField {
2120 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2121 where
2122 D: serde::Deserializer<'de>,
2123 {
2124 struct GeneratedVisitor;
2125
2126 impl serde::de::Visitor<'_> for GeneratedVisitor {
2127 type Value = GeneratedField;
2128
2129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2130 write!(formatter, "expected one of: {:?}", &FIELDS)
2131 }
2132
2133 #[allow(unused_variables)]
2134 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2135 where
2136 E: serde::de::Error,
2137 {
2138 match value {
2139 "version" => Ok(GeneratedField::Version),
2140 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2141 }
2142 }
2143 }
2144 deserializer.deserialize_identifier(GeneratedVisitor)
2145 }
2146 }
2147 struct GeneratedVisitor;
2148 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2149 type Value = AlterSecretResponse;
2150
2151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2152 formatter.write_str("struct ddl_service.AlterSecretResponse")
2153 }
2154
2155 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
2156 where
2157 V: serde::de::MapAccess<'de>,
2158 {
2159 let mut version__ = None;
2160 while let Some(k) = map_.next_key()? {
2161 match k {
2162 GeneratedField::Version => {
2163 if version__.is_some() {
2164 return Err(serde::de::Error::duplicate_field("version"));
2165 }
2166 version__ = map_.next_value()?;
2167 }
2168 }
2169 }
2170 Ok(AlterSecretResponse {
2171 version: version__,
2172 })
2173 }
2174 }
2175 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
2176 }
2177}
2178impl serde::Serialize for AlterSetSchemaRequest {
2179 #[allow(deprecated)]
2180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2181 where
2182 S: serde::Serializer,
2183 {
2184 use serde::ser::SerializeStruct;
2185 let mut len = 0;
2186 if self.new_schema_id != 0 {
2187 len += 1;
2188 }
2189 if self.object.is_some() {
2190 len += 1;
2191 }
2192 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
2193 if self.new_schema_id != 0 {
2194 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
2195 }
2196 if let Some(v) = self.object.as_ref() {
2197 match v {
2198 alter_set_schema_request::Object::TableId(v) => {
2199 struct_ser.serialize_field("tableId", v)?;
2200 }
2201 alter_set_schema_request::Object::ViewId(v) => {
2202 struct_ser.serialize_field("viewId", v)?;
2203 }
2204 alter_set_schema_request::Object::SourceId(v) => {
2205 struct_ser.serialize_field("sourceId", v)?;
2206 }
2207 alter_set_schema_request::Object::SinkId(v) => {
2208 struct_ser.serialize_field("sinkId", v)?;
2209 }
2210 alter_set_schema_request::Object::FunctionId(v) => {
2211 struct_ser.serialize_field("functionId", v)?;
2212 }
2213 alter_set_schema_request::Object::ConnectionId(v) => {
2214 struct_ser.serialize_field("connectionId", v)?;
2215 }
2216 alter_set_schema_request::Object::SubscriptionId(v) => {
2217 struct_ser.serialize_field("subscriptionId", v)?;
2218 }
2219 }
2220 }
2221 struct_ser.end()
2222 }
2223}
2224impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
2225 #[allow(deprecated)]
2226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2227 where
2228 D: serde::Deserializer<'de>,
2229 {
2230 const FIELDS: &[&str] = &[
2231 "new_schema_id",
2232 "newSchemaId",
2233 "table_id",
2234 "tableId",
2235 "view_id",
2236 "viewId",
2237 "source_id",
2238 "sourceId",
2239 "sink_id",
2240 "sinkId",
2241 "function_id",
2242 "functionId",
2243 "connection_id",
2244 "connectionId",
2245 "subscription_id",
2246 "subscriptionId",
2247 ];
2248
2249 #[allow(clippy::enum_variant_names)]
2250 enum GeneratedField {
2251 NewSchemaId,
2252 TableId,
2253 ViewId,
2254 SourceId,
2255 SinkId,
2256 FunctionId,
2257 ConnectionId,
2258 SubscriptionId,
2259 }
2260 impl<'de> serde::Deserialize<'de> for GeneratedField {
2261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2262 where
2263 D: serde::Deserializer<'de>,
2264 {
2265 struct GeneratedVisitor;
2266
2267 impl serde::de::Visitor<'_> for GeneratedVisitor {
2268 type Value = GeneratedField;
2269
2270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2271 write!(formatter, "expected one of: {:?}", &FIELDS)
2272 }
2273
2274 #[allow(unused_variables)]
2275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2276 where
2277 E: serde::de::Error,
2278 {
2279 match value {
2280 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2281 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2282 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2283 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2284 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2285 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2286 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2287 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289 }
2290 }
2291 }
2292 deserializer.deserialize_identifier(GeneratedVisitor)
2293 }
2294 }
2295 struct GeneratedVisitor;
2296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297 type Value = AlterSetSchemaRequest;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2301 }
2302
2303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2304 where
2305 V: serde::de::MapAccess<'de>,
2306 {
2307 let mut new_schema_id__ = None;
2308 let mut object__ = None;
2309 while let Some(k) = map_.next_key()? {
2310 match k {
2311 GeneratedField::NewSchemaId => {
2312 if new_schema_id__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2314 }
2315 new_schema_id__ =
2316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2317 ;
2318 }
2319 GeneratedField::TableId => {
2320 if object__.is_some() {
2321 return Err(serde::de::Error::duplicate_field("tableId"));
2322 }
2323 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2324 }
2325 GeneratedField::ViewId => {
2326 if object__.is_some() {
2327 return Err(serde::de::Error::duplicate_field("viewId"));
2328 }
2329 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2330 }
2331 GeneratedField::SourceId => {
2332 if object__.is_some() {
2333 return Err(serde::de::Error::duplicate_field("sourceId"));
2334 }
2335 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2336 }
2337 GeneratedField::SinkId => {
2338 if object__.is_some() {
2339 return Err(serde::de::Error::duplicate_field("sinkId"));
2340 }
2341 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2342 }
2343 GeneratedField::FunctionId => {
2344 if object__.is_some() {
2345 return Err(serde::de::Error::duplicate_field("functionId"));
2346 }
2347 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2348 }
2349 GeneratedField::ConnectionId => {
2350 if object__.is_some() {
2351 return Err(serde::de::Error::duplicate_field("connectionId"));
2352 }
2353 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2354 }
2355 GeneratedField::SubscriptionId => {
2356 if object__.is_some() {
2357 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2358 }
2359 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2360 }
2361 }
2362 }
2363 Ok(AlterSetSchemaRequest {
2364 new_schema_id: new_schema_id__.unwrap_or_default(),
2365 object: object__,
2366 })
2367 }
2368 }
2369 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2370 }
2371}
2372impl serde::Serialize for AlterSetSchemaResponse {
2373 #[allow(deprecated)]
2374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2375 where
2376 S: serde::Serializer,
2377 {
2378 use serde::ser::SerializeStruct;
2379 let mut len = 0;
2380 if self.status.is_some() {
2381 len += 1;
2382 }
2383 if self.version.is_some() {
2384 len += 1;
2385 }
2386 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2387 if let Some(v) = self.status.as_ref() {
2388 struct_ser.serialize_field("status", v)?;
2389 }
2390 if let Some(v) = self.version.as_ref() {
2391 struct_ser.serialize_field("version", v)?;
2392 }
2393 struct_ser.end()
2394 }
2395}
2396impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2397 #[allow(deprecated)]
2398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2399 where
2400 D: serde::Deserializer<'de>,
2401 {
2402 const FIELDS: &[&str] = &[
2403 "status",
2404 "version",
2405 ];
2406
2407 #[allow(clippy::enum_variant_names)]
2408 enum GeneratedField {
2409 Status,
2410 Version,
2411 }
2412 impl<'de> serde::Deserialize<'de> for GeneratedField {
2413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2414 where
2415 D: serde::Deserializer<'de>,
2416 {
2417 struct GeneratedVisitor;
2418
2419 impl serde::de::Visitor<'_> for GeneratedVisitor {
2420 type Value = GeneratedField;
2421
2422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2423 write!(formatter, "expected one of: {:?}", &FIELDS)
2424 }
2425
2426 #[allow(unused_variables)]
2427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2428 where
2429 E: serde::de::Error,
2430 {
2431 match value {
2432 "status" => Ok(GeneratedField::Status),
2433 "version" => Ok(GeneratedField::Version),
2434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2435 }
2436 }
2437 }
2438 deserializer.deserialize_identifier(GeneratedVisitor)
2439 }
2440 }
2441 struct GeneratedVisitor;
2442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2443 type Value = AlterSetSchemaResponse;
2444
2445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2446 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2447 }
2448
2449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2450 where
2451 V: serde::de::MapAccess<'de>,
2452 {
2453 let mut status__ = None;
2454 let mut version__ = None;
2455 while let Some(k) = map_.next_key()? {
2456 match k {
2457 GeneratedField::Status => {
2458 if status__.is_some() {
2459 return Err(serde::de::Error::duplicate_field("status"));
2460 }
2461 status__ = map_.next_value()?;
2462 }
2463 GeneratedField::Version => {
2464 if version__.is_some() {
2465 return Err(serde::de::Error::duplicate_field("version"));
2466 }
2467 version__ = map_.next_value()?;
2468 }
2469 }
2470 }
2471 Ok(AlterSetSchemaResponse {
2472 status: status__,
2473 version: version__,
2474 })
2475 }
2476 }
2477 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2478 }
2479}
2480impl serde::Serialize for AlterSourceRequest {
2481 #[allow(deprecated)]
2482 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2483 where
2484 S: serde::Serializer,
2485 {
2486 use serde::ser::SerializeStruct;
2487 let mut len = 0;
2488 if self.source.is_some() {
2489 len += 1;
2490 }
2491 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2492 if let Some(v) = self.source.as_ref() {
2493 struct_ser.serialize_field("source", v)?;
2494 }
2495 struct_ser.end()
2496 }
2497}
2498impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2499 #[allow(deprecated)]
2500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2501 where
2502 D: serde::Deserializer<'de>,
2503 {
2504 const FIELDS: &[&str] = &[
2505 "source",
2506 ];
2507
2508 #[allow(clippy::enum_variant_names)]
2509 enum GeneratedField {
2510 Source,
2511 }
2512 impl<'de> serde::Deserialize<'de> for GeneratedField {
2513 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2514 where
2515 D: serde::Deserializer<'de>,
2516 {
2517 struct GeneratedVisitor;
2518
2519 impl serde::de::Visitor<'_> for GeneratedVisitor {
2520 type Value = GeneratedField;
2521
2522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2523 write!(formatter, "expected one of: {:?}", &FIELDS)
2524 }
2525
2526 #[allow(unused_variables)]
2527 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2528 where
2529 E: serde::de::Error,
2530 {
2531 match value {
2532 "source" => Ok(GeneratedField::Source),
2533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2534 }
2535 }
2536 }
2537 deserializer.deserialize_identifier(GeneratedVisitor)
2538 }
2539 }
2540 struct GeneratedVisitor;
2541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2542 type Value = AlterSourceRequest;
2543
2544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2545 formatter.write_str("struct ddl_service.AlterSourceRequest")
2546 }
2547
2548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2549 where
2550 V: serde::de::MapAccess<'de>,
2551 {
2552 let mut source__ = None;
2553 while let Some(k) = map_.next_key()? {
2554 match k {
2555 GeneratedField::Source => {
2556 if source__.is_some() {
2557 return Err(serde::de::Error::duplicate_field("source"));
2558 }
2559 source__ = map_.next_value()?;
2560 }
2561 }
2562 }
2563 Ok(AlterSourceRequest {
2564 source: source__,
2565 })
2566 }
2567 }
2568 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2569 }
2570}
2571impl serde::Serialize for AlterSourceResponse {
2572 #[allow(deprecated)]
2573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2574 where
2575 S: serde::Serializer,
2576 {
2577 use serde::ser::SerializeStruct;
2578 let mut len = 0;
2579 if self.status.is_some() {
2580 len += 1;
2581 }
2582 if self.version.is_some() {
2583 len += 1;
2584 }
2585 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2586 if let Some(v) = self.status.as_ref() {
2587 struct_ser.serialize_field("status", v)?;
2588 }
2589 if let Some(v) = self.version.as_ref() {
2590 struct_ser.serialize_field("version", v)?;
2591 }
2592 struct_ser.end()
2593 }
2594}
2595impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2596 #[allow(deprecated)]
2597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2598 where
2599 D: serde::Deserializer<'de>,
2600 {
2601 const FIELDS: &[&str] = &[
2602 "status",
2603 "version",
2604 ];
2605
2606 #[allow(clippy::enum_variant_names)]
2607 enum GeneratedField {
2608 Status,
2609 Version,
2610 }
2611 impl<'de> serde::Deserialize<'de> for GeneratedField {
2612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2613 where
2614 D: serde::Deserializer<'de>,
2615 {
2616 struct GeneratedVisitor;
2617
2618 impl serde::de::Visitor<'_> for GeneratedVisitor {
2619 type Value = GeneratedField;
2620
2621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2622 write!(formatter, "expected one of: {:?}", &FIELDS)
2623 }
2624
2625 #[allow(unused_variables)]
2626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2627 where
2628 E: serde::de::Error,
2629 {
2630 match value {
2631 "status" => Ok(GeneratedField::Status),
2632 "version" => Ok(GeneratedField::Version),
2633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2634 }
2635 }
2636 }
2637 deserializer.deserialize_identifier(GeneratedVisitor)
2638 }
2639 }
2640 struct GeneratedVisitor;
2641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2642 type Value = AlterSourceResponse;
2643
2644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2645 formatter.write_str("struct ddl_service.AlterSourceResponse")
2646 }
2647
2648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2649 where
2650 V: serde::de::MapAccess<'de>,
2651 {
2652 let mut status__ = None;
2653 let mut version__ = None;
2654 while let Some(k) = map_.next_key()? {
2655 match k {
2656 GeneratedField::Status => {
2657 if status__.is_some() {
2658 return Err(serde::de::Error::duplicate_field("status"));
2659 }
2660 status__ = map_.next_value()?;
2661 }
2662 GeneratedField::Version => {
2663 if version__.is_some() {
2664 return Err(serde::de::Error::duplicate_field("version"));
2665 }
2666 version__ = map_.next_value()?;
2667 }
2668 }
2669 }
2670 Ok(AlterSourceResponse {
2671 status: status__,
2672 version: version__,
2673 })
2674 }
2675 }
2676 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2677 }
2678}
2679impl serde::Serialize for AlterStreamingJobConfigRequest {
2680 #[allow(deprecated)]
2681 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2682 where
2683 S: serde::Serializer,
2684 {
2685 use serde::ser::SerializeStruct;
2686 let mut len = 0;
2687 if self.job_id != 0 {
2688 len += 1;
2689 }
2690 if !self.entries_to_add.is_empty() {
2691 len += 1;
2692 }
2693 if !self.keys_to_remove.is_empty() {
2694 len += 1;
2695 }
2696 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigRequest", len)?;
2697 if self.job_id != 0 {
2698 struct_ser.serialize_field("jobId", &self.job_id)?;
2699 }
2700 if !self.entries_to_add.is_empty() {
2701 struct_ser.serialize_field("entriesToAdd", &self.entries_to_add)?;
2702 }
2703 if !self.keys_to_remove.is_empty() {
2704 struct_ser.serialize_field("keysToRemove", &self.keys_to_remove)?;
2705 }
2706 struct_ser.end()
2707 }
2708}
2709impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigRequest {
2710 #[allow(deprecated)]
2711 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2712 where
2713 D: serde::Deserializer<'de>,
2714 {
2715 const FIELDS: &[&str] = &[
2716 "job_id",
2717 "jobId",
2718 "entries_to_add",
2719 "entriesToAdd",
2720 "keys_to_remove",
2721 "keysToRemove",
2722 ];
2723
2724 #[allow(clippy::enum_variant_names)]
2725 enum GeneratedField {
2726 JobId,
2727 EntriesToAdd,
2728 KeysToRemove,
2729 }
2730 impl<'de> serde::Deserialize<'de> for GeneratedField {
2731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2732 where
2733 D: serde::Deserializer<'de>,
2734 {
2735 struct GeneratedVisitor;
2736
2737 impl serde::de::Visitor<'_> for GeneratedVisitor {
2738 type Value = GeneratedField;
2739
2740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2741 write!(formatter, "expected one of: {:?}", &FIELDS)
2742 }
2743
2744 #[allow(unused_variables)]
2745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2746 where
2747 E: serde::de::Error,
2748 {
2749 match value {
2750 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2751 "entriesToAdd" | "entries_to_add" => Ok(GeneratedField::EntriesToAdd),
2752 "keysToRemove" | "keys_to_remove" => Ok(GeneratedField::KeysToRemove),
2753 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2754 }
2755 }
2756 }
2757 deserializer.deserialize_identifier(GeneratedVisitor)
2758 }
2759 }
2760 struct GeneratedVisitor;
2761 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2762 type Value = AlterStreamingJobConfigRequest;
2763
2764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2765 formatter.write_str("struct ddl_service.AlterStreamingJobConfigRequest")
2766 }
2767
2768 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigRequest, V::Error>
2769 where
2770 V: serde::de::MapAccess<'de>,
2771 {
2772 let mut job_id__ = None;
2773 let mut entries_to_add__ = None;
2774 let mut keys_to_remove__ = None;
2775 while let Some(k) = map_.next_key()? {
2776 match k {
2777 GeneratedField::JobId => {
2778 if job_id__.is_some() {
2779 return Err(serde::de::Error::duplicate_field("jobId"));
2780 }
2781 job_id__ =
2782 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2783 ;
2784 }
2785 GeneratedField::EntriesToAdd => {
2786 if entries_to_add__.is_some() {
2787 return Err(serde::de::Error::duplicate_field("entriesToAdd"));
2788 }
2789 entries_to_add__ = Some(
2790 map_.next_value::<std::collections::HashMap<_, _>>()?
2791 );
2792 }
2793 GeneratedField::KeysToRemove => {
2794 if keys_to_remove__.is_some() {
2795 return Err(serde::de::Error::duplicate_field("keysToRemove"));
2796 }
2797 keys_to_remove__ = Some(map_.next_value()?);
2798 }
2799 }
2800 }
2801 Ok(AlterStreamingJobConfigRequest {
2802 job_id: job_id__.unwrap_or_default(),
2803 entries_to_add: entries_to_add__.unwrap_or_default(),
2804 keys_to_remove: keys_to_remove__.unwrap_or_default(),
2805 })
2806 }
2807 }
2808 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigRequest", FIELDS, GeneratedVisitor)
2809 }
2810}
2811impl serde::Serialize for AlterStreamingJobConfigResponse {
2812 #[allow(deprecated)]
2813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2814 where
2815 S: serde::Serializer,
2816 {
2817 use serde::ser::SerializeStruct;
2818 let len = 0;
2819 let struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigResponse", len)?;
2820 struct_ser.end()
2821 }
2822}
2823impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigResponse {
2824 #[allow(deprecated)]
2825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2826 where
2827 D: serde::Deserializer<'de>,
2828 {
2829 const FIELDS: &[&str] = &[
2830 ];
2831
2832 #[allow(clippy::enum_variant_names)]
2833 enum GeneratedField {
2834 }
2835 impl<'de> serde::Deserialize<'de> for GeneratedField {
2836 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2837 where
2838 D: serde::Deserializer<'de>,
2839 {
2840 struct GeneratedVisitor;
2841
2842 impl serde::de::Visitor<'_> for GeneratedVisitor {
2843 type Value = GeneratedField;
2844
2845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2846 write!(formatter, "expected one of: {:?}", &FIELDS)
2847 }
2848
2849 #[allow(unused_variables)]
2850 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2851 where
2852 E: serde::de::Error,
2853 {
2854 Err(serde::de::Error::unknown_field(value, FIELDS))
2855 }
2856 }
2857 deserializer.deserialize_identifier(GeneratedVisitor)
2858 }
2859 }
2860 struct GeneratedVisitor;
2861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2862 type Value = AlterStreamingJobConfigResponse;
2863
2864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2865 formatter.write_str("struct ddl_service.AlterStreamingJobConfigResponse")
2866 }
2867
2868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigResponse, V::Error>
2869 where
2870 V: serde::de::MapAccess<'de>,
2871 {
2872 while map_.next_key::<GeneratedField>()?.is_some() {
2873 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2874 }
2875 Ok(AlterStreamingJobConfigResponse {
2876 })
2877 }
2878 }
2879 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigResponse", FIELDS, GeneratedVisitor)
2880 }
2881}
2882impl serde::Serialize for AlterSubscriptionRetentionRequest {
2883 #[allow(deprecated)]
2884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2885 where
2886 S: serde::Serializer,
2887 {
2888 use serde::ser::SerializeStruct;
2889 let mut len = 0;
2890 if self.subscription_id != 0 {
2891 len += 1;
2892 }
2893 if self.retention_seconds != 0 {
2894 len += 1;
2895 }
2896 if !self.definition.is_empty() {
2897 len += 1;
2898 }
2899 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionRequest", len)?;
2900 if self.subscription_id != 0 {
2901 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
2902 }
2903 if self.retention_seconds != 0 {
2904 #[allow(clippy::needless_borrow)]
2905 #[allow(clippy::needless_borrows_for_generic_args)]
2906 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
2907 }
2908 if !self.definition.is_empty() {
2909 struct_ser.serialize_field("definition", &self.definition)?;
2910 }
2911 struct_ser.end()
2912 }
2913}
2914impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionRequest {
2915 #[allow(deprecated)]
2916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2917 where
2918 D: serde::Deserializer<'de>,
2919 {
2920 const FIELDS: &[&str] = &[
2921 "subscription_id",
2922 "subscriptionId",
2923 "retention_seconds",
2924 "retentionSeconds",
2925 "definition",
2926 ];
2927
2928 #[allow(clippy::enum_variant_names)]
2929 enum GeneratedField {
2930 SubscriptionId,
2931 RetentionSeconds,
2932 Definition,
2933 }
2934 impl<'de> serde::Deserialize<'de> for GeneratedField {
2935 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2936 where
2937 D: serde::Deserializer<'de>,
2938 {
2939 struct GeneratedVisitor;
2940
2941 impl serde::de::Visitor<'_> for GeneratedVisitor {
2942 type Value = GeneratedField;
2943
2944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2945 write!(formatter, "expected one of: {:?}", &FIELDS)
2946 }
2947
2948 #[allow(unused_variables)]
2949 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2950 where
2951 E: serde::de::Error,
2952 {
2953 match value {
2954 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2955 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
2956 "definition" => Ok(GeneratedField::Definition),
2957 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2958 }
2959 }
2960 }
2961 deserializer.deserialize_identifier(GeneratedVisitor)
2962 }
2963 }
2964 struct GeneratedVisitor;
2965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2966 type Value = AlterSubscriptionRetentionRequest;
2967
2968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2969 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionRequest")
2970 }
2971
2972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionRequest, V::Error>
2973 where
2974 V: serde::de::MapAccess<'de>,
2975 {
2976 let mut subscription_id__ = None;
2977 let mut retention_seconds__ = None;
2978 let mut definition__ = None;
2979 while let Some(k) = map_.next_key()? {
2980 match k {
2981 GeneratedField::SubscriptionId => {
2982 if subscription_id__.is_some() {
2983 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2984 }
2985 subscription_id__ =
2986 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2987 ;
2988 }
2989 GeneratedField::RetentionSeconds => {
2990 if retention_seconds__.is_some() {
2991 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
2992 }
2993 retention_seconds__ =
2994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2995 ;
2996 }
2997 GeneratedField::Definition => {
2998 if definition__.is_some() {
2999 return Err(serde::de::Error::duplicate_field("definition"));
3000 }
3001 definition__ = Some(map_.next_value()?);
3002 }
3003 }
3004 }
3005 Ok(AlterSubscriptionRetentionRequest {
3006 subscription_id: subscription_id__.unwrap_or_default(),
3007 retention_seconds: retention_seconds__.unwrap_or_default(),
3008 definition: definition__.unwrap_or_default(),
3009 })
3010 }
3011 }
3012 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionRequest", FIELDS, GeneratedVisitor)
3013 }
3014}
3015impl serde::Serialize for AlterSubscriptionRetentionResponse {
3016 #[allow(deprecated)]
3017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3018 where
3019 S: serde::Serializer,
3020 {
3021 use serde::ser::SerializeStruct;
3022 let mut len = 0;
3023 if self.status.is_some() {
3024 len += 1;
3025 }
3026 if self.version.is_some() {
3027 len += 1;
3028 }
3029 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionResponse", len)?;
3030 if let Some(v) = self.status.as_ref() {
3031 struct_ser.serialize_field("status", v)?;
3032 }
3033 if let Some(v) = self.version.as_ref() {
3034 struct_ser.serialize_field("version", v)?;
3035 }
3036 struct_ser.end()
3037 }
3038}
3039impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionResponse {
3040 #[allow(deprecated)]
3041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3042 where
3043 D: serde::Deserializer<'de>,
3044 {
3045 const FIELDS: &[&str] = &[
3046 "status",
3047 "version",
3048 ];
3049
3050 #[allow(clippy::enum_variant_names)]
3051 enum GeneratedField {
3052 Status,
3053 Version,
3054 }
3055 impl<'de> serde::Deserialize<'de> for GeneratedField {
3056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3057 where
3058 D: serde::Deserializer<'de>,
3059 {
3060 struct GeneratedVisitor;
3061
3062 impl serde::de::Visitor<'_> for GeneratedVisitor {
3063 type Value = GeneratedField;
3064
3065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3066 write!(formatter, "expected one of: {:?}", &FIELDS)
3067 }
3068
3069 #[allow(unused_variables)]
3070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3071 where
3072 E: serde::de::Error,
3073 {
3074 match value {
3075 "status" => Ok(GeneratedField::Status),
3076 "version" => Ok(GeneratedField::Version),
3077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3078 }
3079 }
3080 }
3081 deserializer.deserialize_identifier(GeneratedVisitor)
3082 }
3083 }
3084 struct GeneratedVisitor;
3085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3086 type Value = AlterSubscriptionRetentionResponse;
3087
3088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3089 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionResponse")
3090 }
3091
3092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionResponse, V::Error>
3093 where
3094 V: serde::de::MapAccess<'de>,
3095 {
3096 let mut status__ = None;
3097 let mut version__ = None;
3098 while let Some(k) = map_.next_key()? {
3099 match k {
3100 GeneratedField::Status => {
3101 if status__.is_some() {
3102 return Err(serde::de::Error::duplicate_field("status"));
3103 }
3104 status__ = map_.next_value()?;
3105 }
3106 GeneratedField::Version => {
3107 if version__.is_some() {
3108 return Err(serde::de::Error::duplicate_field("version"));
3109 }
3110 version__ = map_.next_value()?;
3111 }
3112 }
3113 }
3114 Ok(AlterSubscriptionRetentionResponse {
3115 status: status__,
3116 version: version__,
3117 })
3118 }
3119 }
3120 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionResponse", FIELDS, GeneratedVisitor)
3121 }
3122}
3123impl serde::Serialize for AlterSwapRenameRequest {
3124 #[allow(deprecated)]
3125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3126 where
3127 S: serde::Serializer,
3128 {
3129 use serde::ser::SerializeStruct;
3130 let mut len = 0;
3131 if self.object.is_some() {
3132 len += 1;
3133 }
3134 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
3135 if let Some(v) = self.object.as_ref() {
3136 match v {
3137 alter_swap_rename_request::Object::Schema(v) => {
3138 struct_ser.serialize_field("schema", v)?;
3139 }
3140 alter_swap_rename_request::Object::Table(v) => {
3141 struct_ser.serialize_field("table", v)?;
3142 }
3143 alter_swap_rename_request::Object::View(v) => {
3144 struct_ser.serialize_field("view", v)?;
3145 }
3146 alter_swap_rename_request::Object::Source(v) => {
3147 struct_ser.serialize_field("source", v)?;
3148 }
3149 alter_swap_rename_request::Object::Sink(v) => {
3150 struct_ser.serialize_field("sink", v)?;
3151 }
3152 alter_swap_rename_request::Object::Subscription(v) => {
3153 struct_ser.serialize_field("subscription", v)?;
3154 }
3155 }
3156 }
3157 struct_ser.end()
3158 }
3159}
3160impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
3161 #[allow(deprecated)]
3162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3163 where
3164 D: serde::Deserializer<'de>,
3165 {
3166 const FIELDS: &[&str] = &[
3167 "schema",
3168 "table",
3169 "view",
3170 "source",
3171 "sink",
3172 "subscription",
3173 ];
3174
3175 #[allow(clippy::enum_variant_names)]
3176 enum GeneratedField {
3177 Schema,
3178 Table,
3179 View,
3180 Source,
3181 Sink,
3182 Subscription,
3183 }
3184 impl<'de> serde::Deserialize<'de> for GeneratedField {
3185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3186 where
3187 D: serde::Deserializer<'de>,
3188 {
3189 struct GeneratedVisitor;
3190
3191 impl serde::de::Visitor<'_> for GeneratedVisitor {
3192 type Value = GeneratedField;
3193
3194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3195 write!(formatter, "expected one of: {:?}", &FIELDS)
3196 }
3197
3198 #[allow(unused_variables)]
3199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3200 where
3201 E: serde::de::Error,
3202 {
3203 match value {
3204 "schema" => Ok(GeneratedField::Schema),
3205 "table" => Ok(GeneratedField::Table),
3206 "view" => Ok(GeneratedField::View),
3207 "source" => Ok(GeneratedField::Source),
3208 "sink" => Ok(GeneratedField::Sink),
3209 "subscription" => Ok(GeneratedField::Subscription),
3210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3211 }
3212 }
3213 }
3214 deserializer.deserialize_identifier(GeneratedVisitor)
3215 }
3216 }
3217 struct GeneratedVisitor;
3218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3219 type Value = AlterSwapRenameRequest;
3220
3221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3222 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
3223 }
3224
3225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
3226 where
3227 V: serde::de::MapAccess<'de>,
3228 {
3229 let mut object__ = None;
3230 while let Some(k) = map_.next_key()? {
3231 match k {
3232 GeneratedField::Schema => {
3233 if object__.is_some() {
3234 return Err(serde::de::Error::duplicate_field("schema"));
3235 }
3236 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
3237;
3238 }
3239 GeneratedField::Table => {
3240 if object__.is_some() {
3241 return Err(serde::de::Error::duplicate_field("table"));
3242 }
3243 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
3244;
3245 }
3246 GeneratedField::View => {
3247 if object__.is_some() {
3248 return Err(serde::de::Error::duplicate_field("view"));
3249 }
3250 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
3251;
3252 }
3253 GeneratedField::Source => {
3254 if object__.is_some() {
3255 return Err(serde::de::Error::duplicate_field("source"));
3256 }
3257 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
3258;
3259 }
3260 GeneratedField::Sink => {
3261 if object__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("sink"));
3263 }
3264 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
3265;
3266 }
3267 GeneratedField::Subscription => {
3268 if object__.is_some() {
3269 return Err(serde::de::Error::duplicate_field("subscription"));
3270 }
3271 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
3272;
3273 }
3274 }
3275 }
3276 Ok(AlterSwapRenameRequest {
3277 object: object__,
3278 })
3279 }
3280 }
3281 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
3282 }
3283}
3284impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
3285 #[allow(deprecated)]
3286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3287 where
3288 S: serde::Serializer,
3289 {
3290 use serde::ser::SerializeStruct;
3291 let mut len = 0;
3292 if self.src_object_id != 0 {
3293 len += 1;
3294 }
3295 if self.dst_object_id != 0 {
3296 len += 1;
3297 }
3298 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
3299 if self.src_object_id != 0 {
3300 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
3301 }
3302 if self.dst_object_id != 0 {
3303 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
3304 }
3305 struct_ser.end()
3306 }
3307}
3308impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
3309 #[allow(deprecated)]
3310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3311 where
3312 D: serde::Deserializer<'de>,
3313 {
3314 const FIELDS: &[&str] = &[
3315 "src_object_id",
3316 "srcObjectId",
3317 "dst_object_id",
3318 "dstObjectId",
3319 ];
3320
3321 #[allow(clippy::enum_variant_names)]
3322 enum GeneratedField {
3323 SrcObjectId,
3324 DstObjectId,
3325 }
3326 impl<'de> serde::Deserialize<'de> for GeneratedField {
3327 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3328 where
3329 D: serde::Deserializer<'de>,
3330 {
3331 struct GeneratedVisitor;
3332
3333 impl serde::de::Visitor<'_> for GeneratedVisitor {
3334 type Value = GeneratedField;
3335
3336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3337 write!(formatter, "expected one of: {:?}", &FIELDS)
3338 }
3339
3340 #[allow(unused_variables)]
3341 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3342 where
3343 E: serde::de::Error,
3344 {
3345 match value {
3346 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
3347 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
3348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3349 }
3350 }
3351 }
3352 deserializer.deserialize_identifier(GeneratedVisitor)
3353 }
3354 }
3355 struct GeneratedVisitor;
3356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3357 type Value = alter_swap_rename_request::ObjectNameSwapPair;
3358
3359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3360 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
3361 }
3362
3363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
3364 where
3365 V: serde::de::MapAccess<'de>,
3366 {
3367 let mut src_object_id__ = None;
3368 let mut dst_object_id__ = None;
3369 while let Some(k) = map_.next_key()? {
3370 match k {
3371 GeneratedField::SrcObjectId => {
3372 if src_object_id__.is_some() {
3373 return Err(serde::de::Error::duplicate_field("srcObjectId"));
3374 }
3375 src_object_id__ =
3376 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3377 ;
3378 }
3379 GeneratedField::DstObjectId => {
3380 if dst_object_id__.is_some() {
3381 return Err(serde::de::Error::duplicate_field("dstObjectId"));
3382 }
3383 dst_object_id__ =
3384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3385 ;
3386 }
3387 }
3388 }
3389 Ok(alter_swap_rename_request::ObjectNameSwapPair {
3390 src_object_id: src_object_id__.unwrap_or_default(),
3391 dst_object_id: dst_object_id__.unwrap_or_default(),
3392 })
3393 }
3394 }
3395 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
3396 }
3397}
3398impl serde::Serialize for AlterSwapRenameResponse {
3399 #[allow(deprecated)]
3400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3401 where
3402 S: serde::Serializer,
3403 {
3404 use serde::ser::SerializeStruct;
3405 let mut len = 0;
3406 if self.status.is_some() {
3407 len += 1;
3408 }
3409 if self.version.is_some() {
3410 len += 1;
3411 }
3412 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
3413 if let Some(v) = self.status.as_ref() {
3414 struct_ser.serialize_field("status", v)?;
3415 }
3416 if let Some(v) = self.version.as_ref() {
3417 struct_ser.serialize_field("version", v)?;
3418 }
3419 struct_ser.end()
3420 }
3421}
3422impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
3423 #[allow(deprecated)]
3424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3425 where
3426 D: serde::Deserializer<'de>,
3427 {
3428 const FIELDS: &[&str] = &[
3429 "status",
3430 "version",
3431 ];
3432
3433 #[allow(clippy::enum_variant_names)]
3434 enum GeneratedField {
3435 Status,
3436 Version,
3437 }
3438 impl<'de> serde::Deserialize<'de> for GeneratedField {
3439 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3440 where
3441 D: serde::Deserializer<'de>,
3442 {
3443 struct GeneratedVisitor;
3444
3445 impl serde::de::Visitor<'_> for GeneratedVisitor {
3446 type Value = GeneratedField;
3447
3448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3449 write!(formatter, "expected one of: {:?}", &FIELDS)
3450 }
3451
3452 #[allow(unused_variables)]
3453 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3454 where
3455 E: serde::de::Error,
3456 {
3457 match value {
3458 "status" => Ok(GeneratedField::Status),
3459 "version" => Ok(GeneratedField::Version),
3460 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3461 }
3462 }
3463 }
3464 deserializer.deserialize_identifier(GeneratedVisitor)
3465 }
3466 }
3467 struct GeneratedVisitor;
3468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3469 type Value = AlterSwapRenameResponse;
3470
3471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3472 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
3473 }
3474
3475 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
3476 where
3477 V: serde::de::MapAccess<'de>,
3478 {
3479 let mut status__ = None;
3480 let mut version__ = None;
3481 while let Some(k) = map_.next_key()? {
3482 match k {
3483 GeneratedField::Status => {
3484 if status__.is_some() {
3485 return Err(serde::de::Error::duplicate_field("status"));
3486 }
3487 status__ = map_.next_value()?;
3488 }
3489 GeneratedField::Version => {
3490 if version__.is_some() {
3491 return Err(serde::de::Error::duplicate_field("version"));
3492 }
3493 version__ = map_.next_value()?;
3494 }
3495 }
3496 }
3497 Ok(AlterSwapRenameResponse {
3498 status: status__,
3499 version: version__,
3500 })
3501 }
3502 }
3503 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
3504 }
3505}
3506impl serde::Serialize for AutoSchemaChangeRequest {
3507 #[allow(deprecated)]
3508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3509 where
3510 S: serde::Serializer,
3511 {
3512 use serde::ser::SerializeStruct;
3513 let mut len = 0;
3514 if self.schema_change.is_some() {
3515 len += 1;
3516 }
3517 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
3518 if let Some(v) = self.schema_change.as_ref() {
3519 struct_ser.serialize_field("schemaChange", v)?;
3520 }
3521 struct_ser.end()
3522 }
3523}
3524impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
3525 #[allow(deprecated)]
3526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3527 where
3528 D: serde::Deserializer<'de>,
3529 {
3530 const FIELDS: &[&str] = &[
3531 "schema_change",
3532 "schemaChange",
3533 ];
3534
3535 #[allow(clippy::enum_variant_names)]
3536 enum GeneratedField {
3537 SchemaChange,
3538 }
3539 impl<'de> serde::Deserialize<'de> for GeneratedField {
3540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3541 where
3542 D: serde::Deserializer<'de>,
3543 {
3544 struct GeneratedVisitor;
3545
3546 impl serde::de::Visitor<'_> for GeneratedVisitor {
3547 type Value = GeneratedField;
3548
3549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3550 write!(formatter, "expected one of: {:?}", &FIELDS)
3551 }
3552
3553 #[allow(unused_variables)]
3554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3555 where
3556 E: serde::de::Error,
3557 {
3558 match value {
3559 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
3560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3561 }
3562 }
3563 }
3564 deserializer.deserialize_identifier(GeneratedVisitor)
3565 }
3566 }
3567 struct GeneratedVisitor;
3568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3569 type Value = AutoSchemaChangeRequest;
3570
3571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3572 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
3573 }
3574
3575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
3576 where
3577 V: serde::de::MapAccess<'de>,
3578 {
3579 let mut schema_change__ = None;
3580 while let Some(k) = map_.next_key()? {
3581 match k {
3582 GeneratedField::SchemaChange => {
3583 if schema_change__.is_some() {
3584 return Err(serde::de::Error::duplicate_field("schemaChange"));
3585 }
3586 schema_change__ = map_.next_value()?;
3587 }
3588 }
3589 }
3590 Ok(AutoSchemaChangeRequest {
3591 schema_change: schema_change__,
3592 })
3593 }
3594 }
3595 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
3596 }
3597}
3598impl serde::Serialize for AutoSchemaChangeResponse {
3599 #[allow(deprecated)]
3600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3601 where
3602 S: serde::Serializer,
3603 {
3604 use serde::ser::SerializeStruct;
3605 let len = 0;
3606 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
3607 struct_ser.end()
3608 }
3609}
3610impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
3611 #[allow(deprecated)]
3612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3613 where
3614 D: serde::Deserializer<'de>,
3615 {
3616 const FIELDS: &[&str] = &[
3617 ];
3618
3619 #[allow(clippy::enum_variant_names)]
3620 enum GeneratedField {
3621 }
3622 impl<'de> serde::Deserialize<'de> for GeneratedField {
3623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3624 where
3625 D: serde::Deserializer<'de>,
3626 {
3627 struct GeneratedVisitor;
3628
3629 impl serde::de::Visitor<'_> for GeneratedVisitor {
3630 type Value = GeneratedField;
3631
3632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3633 write!(formatter, "expected one of: {:?}", &FIELDS)
3634 }
3635
3636 #[allow(unused_variables)]
3637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3638 where
3639 E: serde::de::Error,
3640 {
3641 Err(serde::de::Error::unknown_field(value, FIELDS))
3642 }
3643 }
3644 deserializer.deserialize_identifier(GeneratedVisitor)
3645 }
3646 }
3647 struct GeneratedVisitor;
3648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3649 type Value = AutoSchemaChangeResponse;
3650
3651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3652 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
3653 }
3654
3655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
3656 where
3657 V: serde::de::MapAccess<'de>,
3658 {
3659 while map_.next_key::<GeneratedField>()?.is_some() {
3660 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3661 }
3662 Ok(AutoSchemaChangeResponse {
3663 })
3664 }
3665 }
3666 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
3667 }
3668}
3669impl serde::Serialize for BackfillType {
3670 #[allow(deprecated)]
3671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3672 where
3673 S: serde::Serializer,
3674 {
3675 let variant = match self {
3676 Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
3677 Self::NormalBackfill => "NORMAL_BACKFILL",
3678 Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
3679 };
3680 serializer.serialize_str(variant)
3681 }
3682}
3683impl<'de> serde::Deserialize<'de> for BackfillType {
3684 #[allow(deprecated)]
3685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3686 where
3687 D: serde::Deserializer<'de>,
3688 {
3689 const FIELDS: &[&str] = &[
3690 "BACKFILL_TYPE_UNSPECIFIED",
3691 "NORMAL_BACKFILL",
3692 "SNAPSHOT_BACKFILL",
3693 ];
3694
3695 struct GeneratedVisitor;
3696
3697 impl serde::de::Visitor<'_> for GeneratedVisitor {
3698 type Value = BackfillType;
3699
3700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3701 write!(formatter, "expected one of: {:?}", &FIELDS)
3702 }
3703
3704 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3705 where
3706 E: serde::de::Error,
3707 {
3708 i32::try_from(v)
3709 .ok()
3710 .and_then(|x| x.try_into().ok())
3711 .ok_or_else(|| {
3712 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3713 })
3714 }
3715
3716 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3717 where
3718 E: serde::de::Error,
3719 {
3720 i32::try_from(v)
3721 .ok()
3722 .and_then(|x| x.try_into().ok())
3723 .ok_or_else(|| {
3724 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3725 })
3726 }
3727
3728 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3729 where
3730 E: serde::de::Error,
3731 {
3732 match value {
3733 "BACKFILL_TYPE_UNSPECIFIED" => Ok(BackfillType::Unspecified),
3734 "NORMAL_BACKFILL" => Ok(BackfillType::NormalBackfill),
3735 "SNAPSHOT_BACKFILL" => Ok(BackfillType::SnapshotBackfill),
3736 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3737 }
3738 }
3739 }
3740 deserializer.deserialize_any(GeneratedVisitor)
3741 }
3742}
3743impl serde::Serialize for CommentOnRequest {
3744 #[allow(deprecated)]
3745 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3746 where
3747 S: serde::Serializer,
3748 {
3749 use serde::ser::SerializeStruct;
3750 let mut len = 0;
3751 if self.comment.is_some() {
3752 len += 1;
3753 }
3754 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
3755 if let Some(v) = self.comment.as_ref() {
3756 struct_ser.serialize_field("comment", v)?;
3757 }
3758 struct_ser.end()
3759 }
3760}
3761impl<'de> serde::Deserialize<'de> for CommentOnRequest {
3762 #[allow(deprecated)]
3763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3764 where
3765 D: serde::Deserializer<'de>,
3766 {
3767 const FIELDS: &[&str] = &[
3768 "comment",
3769 ];
3770
3771 #[allow(clippy::enum_variant_names)]
3772 enum GeneratedField {
3773 Comment,
3774 }
3775 impl<'de> serde::Deserialize<'de> for GeneratedField {
3776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3777 where
3778 D: serde::Deserializer<'de>,
3779 {
3780 struct GeneratedVisitor;
3781
3782 impl serde::de::Visitor<'_> for GeneratedVisitor {
3783 type Value = GeneratedField;
3784
3785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3786 write!(formatter, "expected one of: {:?}", &FIELDS)
3787 }
3788
3789 #[allow(unused_variables)]
3790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3791 where
3792 E: serde::de::Error,
3793 {
3794 match value {
3795 "comment" => Ok(GeneratedField::Comment),
3796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3797 }
3798 }
3799 }
3800 deserializer.deserialize_identifier(GeneratedVisitor)
3801 }
3802 }
3803 struct GeneratedVisitor;
3804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3805 type Value = CommentOnRequest;
3806
3807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3808 formatter.write_str("struct ddl_service.CommentOnRequest")
3809 }
3810
3811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
3812 where
3813 V: serde::de::MapAccess<'de>,
3814 {
3815 let mut comment__ = None;
3816 while let Some(k) = map_.next_key()? {
3817 match k {
3818 GeneratedField::Comment => {
3819 if comment__.is_some() {
3820 return Err(serde::de::Error::duplicate_field("comment"));
3821 }
3822 comment__ = map_.next_value()?;
3823 }
3824 }
3825 }
3826 Ok(CommentOnRequest {
3827 comment: comment__,
3828 })
3829 }
3830 }
3831 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
3832 }
3833}
3834impl serde::Serialize for CommentOnResponse {
3835 #[allow(deprecated)]
3836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3837 where
3838 S: serde::Serializer,
3839 {
3840 use serde::ser::SerializeStruct;
3841 let mut len = 0;
3842 if self.status.is_some() {
3843 len += 1;
3844 }
3845 if self.version.is_some() {
3846 len += 1;
3847 }
3848 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
3849 if let Some(v) = self.status.as_ref() {
3850 struct_ser.serialize_field("status", v)?;
3851 }
3852 if let Some(v) = self.version.as_ref() {
3853 struct_ser.serialize_field("version", v)?;
3854 }
3855 struct_ser.end()
3856 }
3857}
3858impl<'de> serde::Deserialize<'de> for CommentOnResponse {
3859 #[allow(deprecated)]
3860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3861 where
3862 D: serde::Deserializer<'de>,
3863 {
3864 const FIELDS: &[&str] = &[
3865 "status",
3866 "version",
3867 ];
3868
3869 #[allow(clippy::enum_variant_names)]
3870 enum GeneratedField {
3871 Status,
3872 Version,
3873 }
3874 impl<'de> serde::Deserialize<'de> for GeneratedField {
3875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3876 where
3877 D: serde::Deserializer<'de>,
3878 {
3879 struct GeneratedVisitor;
3880
3881 impl serde::de::Visitor<'_> for GeneratedVisitor {
3882 type Value = GeneratedField;
3883
3884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3885 write!(formatter, "expected one of: {:?}", &FIELDS)
3886 }
3887
3888 #[allow(unused_variables)]
3889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3890 where
3891 E: serde::de::Error,
3892 {
3893 match value {
3894 "status" => Ok(GeneratedField::Status),
3895 "version" => Ok(GeneratedField::Version),
3896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3897 }
3898 }
3899 }
3900 deserializer.deserialize_identifier(GeneratedVisitor)
3901 }
3902 }
3903 struct GeneratedVisitor;
3904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3905 type Value = CommentOnResponse;
3906
3907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3908 formatter.write_str("struct ddl_service.CommentOnResponse")
3909 }
3910
3911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
3912 where
3913 V: serde::de::MapAccess<'de>,
3914 {
3915 let mut status__ = None;
3916 let mut version__ = None;
3917 while let Some(k) = map_.next_key()? {
3918 match k {
3919 GeneratedField::Status => {
3920 if status__.is_some() {
3921 return Err(serde::de::Error::duplicate_field("status"));
3922 }
3923 status__ = map_.next_value()?;
3924 }
3925 GeneratedField::Version => {
3926 if version__.is_some() {
3927 return Err(serde::de::Error::duplicate_field("version"));
3928 }
3929 version__ = map_.next_value()?;
3930 }
3931 }
3932 }
3933 Ok(CommentOnResponse {
3934 status: status__,
3935 version: version__,
3936 })
3937 }
3938 }
3939 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
3940 }
3941}
3942impl serde::Serialize for CompactIcebergTableRequest {
3943 #[allow(deprecated)]
3944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3945 where
3946 S: serde::Serializer,
3947 {
3948 use serde::ser::SerializeStruct;
3949 let mut len = 0;
3950 if self.sink_id != 0 {
3951 len += 1;
3952 }
3953 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
3954 if self.sink_id != 0 {
3955 struct_ser.serialize_field("sinkId", &self.sink_id)?;
3956 }
3957 struct_ser.end()
3958 }
3959}
3960impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
3961 #[allow(deprecated)]
3962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3963 where
3964 D: serde::Deserializer<'de>,
3965 {
3966 const FIELDS: &[&str] = &[
3967 "sink_id",
3968 "sinkId",
3969 ];
3970
3971 #[allow(clippy::enum_variant_names)]
3972 enum GeneratedField {
3973 SinkId,
3974 }
3975 impl<'de> serde::Deserialize<'de> for GeneratedField {
3976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3977 where
3978 D: serde::Deserializer<'de>,
3979 {
3980 struct GeneratedVisitor;
3981
3982 impl serde::de::Visitor<'_> for GeneratedVisitor {
3983 type Value = GeneratedField;
3984
3985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3986 write!(formatter, "expected one of: {:?}", &FIELDS)
3987 }
3988
3989 #[allow(unused_variables)]
3990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3991 where
3992 E: serde::de::Error,
3993 {
3994 match value {
3995 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
3996 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3997 }
3998 }
3999 }
4000 deserializer.deserialize_identifier(GeneratedVisitor)
4001 }
4002 }
4003 struct GeneratedVisitor;
4004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4005 type Value = CompactIcebergTableRequest;
4006
4007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4008 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
4009 }
4010
4011 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
4012 where
4013 V: serde::de::MapAccess<'de>,
4014 {
4015 let mut sink_id__ = None;
4016 while let Some(k) = map_.next_key()? {
4017 match k {
4018 GeneratedField::SinkId => {
4019 if sink_id__.is_some() {
4020 return Err(serde::de::Error::duplicate_field("sinkId"));
4021 }
4022 sink_id__ =
4023 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4024 ;
4025 }
4026 }
4027 }
4028 Ok(CompactIcebergTableRequest {
4029 sink_id: sink_id__.unwrap_or_default(),
4030 })
4031 }
4032 }
4033 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
4034 }
4035}
4036impl serde::Serialize for CompactIcebergTableResponse {
4037 #[allow(deprecated)]
4038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4039 where
4040 S: serde::Serializer,
4041 {
4042 use serde::ser::SerializeStruct;
4043 let mut len = 0;
4044 if self.status.is_some() {
4045 len += 1;
4046 }
4047 if self.task_id != 0 {
4048 len += 1;
4049 }
4050 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
4051 if let Some(v) = self.status.as_ref() {
4052 struct_ser.serialize_field("status", v)?;
4053 }
4054 if self.task_id != 0 {
4055 #[allow(clippy::needless_borrow)]
4056 #[allow(clippy::needless_borrows_for_generic_args)]
4057 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
4058 }
4059 struct_ser.end()
4060 }
4061}
4062impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
4063 #[allow(deprecated)]
4064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4065 where
4066 D: serde::Deserializer<'de>,
4067 {
4068 const FIELDS: &[&str] = &[
4069 "status",
4070 "task_id",
4071 "taskId",
4072 ];
4073
4074 #[allow(clippy::enum_variant_names)]
4075 enum GeneratedField {
4076 Status,
4077 TaskId,
4078 }
4079 impl<'de> serde::Deserialize<'de> for GeneratedField {
4080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4081 where
4082 D: serde::Deserializer<'de>,
4083 {
4084 struct GeneratedVisitor;
4085
4086 impl serde::de::Visitor<'_> for GeneratedVisitor {
4087 type Value = GeneratedField;
4088
4089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090 write!(formatter, "expected one of: {:?}", &FIELDS)
4091 }
4092
4093 #[allow(unused_variables)]
4094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4095 where
4096 E: serde::de::Error,
4097 {
4098 match value {
4099 "status" => Ok(GeneratedField::Status),
4100 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
4101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4102 }
4103 }
4104 }
4105 deserializer.deserialize_identifier(GeneratedVisitor)
4106 }
4107 }
4108 struct GeneratedVisitor;
4109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4110 type Value = CompactIcebergTableResponse;
4111
4112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4113 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
4114 }
4115
4116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
4117 where
4118 V: serde::de::MapAccess<'de>,
4119 {
4120 let mut status__ = None;
4121 let mut task_id__ = None;
4122 while let Some(k) = map_.next_key()? {
4123 match k {
4124 GeneratedField::Status => {
4125 if status__.is_some() {
4126 return Err(serde::de::Error::duplicate_field("status"));
4127 }
4128 status__ = map_.next_value()?;
4129 }
4130 GeneratedField::TaskId => {
4131 if task_id__.is_some() {
4132 return Err(serde::de::Error::duplicate_field("taskId"));
4133 }
4134 task_id__ =
4135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4136 ;
4137 }
4138 }
4139 }
4140 Ok(CompactIcebergTableResponse {
4141 status: status__,
4142 task_id: task_id__.unwrap_or_default(),
4143 })
4144 }
4145 }
4146 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
4147 }
4148}
4149impl serde::Serialize for CreateConnectionRequest {
4150 #[allow(deprecated)]
4151 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4152 where
4153 S: serde::Serializer,
4154 {
4155 use serde::ser::SerializeStruct;
4156 let mut len = 0;
4157 if !self.name.is_empty() {
4158 len += 1;
4159 }
4160 if self.database_id != 0 {
4161 len += 1;
4162 }
4163 if self.schema_id != 0 {
4164 len += 1;
4165 }
4166 if self.owner_id != 0 {
4167 len += 1;
4168 }
4169 if self.payload.is_some() {
4170 len += 1;
4171 }
4172 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
4173 if !self.name.is_empty() {
4174 struct_ser.serialize_field("name", &self.name)?;
4175 }
4176 if self.database_id != 0 {
4177 struct_ser.serialize_field("databaseId", &self.database_id)?;
4178 }
4179 if self.schema_id != 0 {
4180 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4181 }
4182 if self.owner_id != 0 {
4183 struct_ser.serialize_field("ownerId", &self.owner_id)?;
4184 }
4185 if let Some(v) = self.payload.as_ref() {
4186 match v {
4187 create_connection_request::Payload::PrivateLink(v) => {
4188 struct_ser.serialize_field("privateLink", v)?;
4189 }
4190 create_connection_request::Payload::ConnectionParams(v) => {
4191 struct_ser.serialize_field("connectionParams", v)?;
4192 }
4193 }
4194 }
4195 struct_ser.end()
4196 }
4197}
4198impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
4199 #[allow(deprecated)]
4200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4201 where
4202 D: serde::Deserializer<'de>,
4203 {
4204 const FIELDS: &[&str] = &[
4205 "name",
4206 "database_id",
4207 "databaseId",
4208 "schema_id",
4209 "schemaId",
4210 "owner_id",
4211 "ownerId",
4212 "private_link",
4213 "privateLink",
4214 "connection_params",
4215 "connectionParams",
4216 ];
4217
4218 #[allow(clippy::enum_variant_names)]
4219 enum GeneratedField {
4220 Name,
4221 DatabaseId,
4222 SchemaId,
4223 OwnerId,
4224 PrivateLink,
4225 ConnectionParams,
4226 }
4227 impl<'de> serde::Deserialize<'de> for GeneratedField {
4228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4229 where
4230 D: serde::Deserializer<'de>,
4231 {
4232 struct GeneratedVisitor;
4233
4234 impl serde::de::Visitor<'_> for GeneratedVisitor {
4235 type Value = GeneratedField;
4236
4237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4238 write!(formatter, "expected one of: {:?}", &FIELDS)
4239 }
4240
4241 #[allow(unused_variables)]
4242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4243 where
4244 E: serde::de::Error,
4245 {
4246 match value {
4247 "name" => Ok(GeneratedField::Name),
4248 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4249 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4250 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
4251 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
4252 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
4253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4254 }
4255 }
4256 }
4257 deserializer.deserialize_identifier(GeneratedVisitor)
4258 }
4259 }
4260 struct GeneratedVisitor;
4261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4262 type Value = CreateConnectionRequest;
4263
4264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4265 formatter.write_str("struct ddl_service.CreateConnectionRequest")
4266 }
4267
4268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
4269 where
4270 V: serde::de::MapAccess<'de>,
4271 {
4272 let mut name__ = None;
4273 let mut database_id__ = None;
4274 let mut schema_id__ = None;
4275 let mut owner_id__ = None;
4276 let mut payload__ = None;
4277 while let Some(k) = map_.next_key()? {
4278 match k {
4279 GeneratedField::Name => {
4280 if name__.is_some() {
4281 return Err(serde::de::Error::duplicate_field("name"));
4282 }
4283 name__ = Some(map_.next_value()?);
4284 }
4285 GeneratedField::DatabaseId => {
4286 if database_id__.is_some() {
4287 return Err(serde::de::Error::duplicate_field("databaseId"));
4288 }
4289 database_id__ =
4290 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4291 ;
4292 }
4293 GeneratedField::SchemaId => {
4294 if schema_id__.is_some() {
4295 return Err(serde::de::Error::duplicate_field("schemaId"));
4296 }
4297 schema_id__ =
4298 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4299 ;
4300 }
4301 GeneratedField::OwnerId => {
4302 if owner_id__.is_some() {
4303 return Err(serde::de::Error::duplicate_field("ownerId"));
4304 }
4305 owner_id__ =
4306 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4307 ;
4308 }
4309 GeneratedField::PrivateLink => {
4310 if payload__.is_some() {
4311 return Err(serde::de::Error::duplicate_field("privateLink"));
4312 }
4313 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
4314;
4315 }
4316 GeneratedField::ConnectionParams => {
4317 if payload__.is_some() {
4318 return Err(serde::de::Error::duplicate_field("connectionParams"));
4319 }
4320 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
4321;
4322 }
4323 }
4324 }
4325 Ok(CreateConnectionRequest {
4326 name: name__.unwrap_or_default(),
4327 database_id: database_id__.unwrap_or_default(),
4328 schema_id: schema_id__.unwrap_or_default(),
4329 owner_id: owner_id__.unwrap_or_default(),
4330 payload: payload__,
4331 })
4332 }
4333 }
4334 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
4335 }
4336}
4337impl serde::Serialize for create_connection_request::PrivateLink {
4338 #[allow(deprecated)]
4339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4340 where
4341 S: serde::Serializer,
4342 {
4343 use serde::ser::SerializeStruct;
4344 let mut len = 0;
4345 if self.provider != 0 {
4346 len += 1;
4347 }
4348 if !self.service_name.is_empty() {
4349 len += 1;
4350 }
4351 if self.tags.is_some() {
4352 len += 1;
4353 }
4354 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
4355 if self.provider != 0 {
4356 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
4357 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
4358 struct_ser.serialize_field("provider", &v)?;
4359 }
4360 if !self.service_name.is_empty() {
4361 struct_ser.serialize_field("serviceName", &self.service_name)?;
4362 }
4363 if let Some(v) = self.tags.as_ref() {
4364 struct_ser.serialize_field("tags", v)?;
4365 }
4366 struct_ser.end()
4367 }
4368}
4369impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
4370 #[allow(deprecated)]
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 const FIELDS: &[&str] = &[
4376 "provider",
4377 "service_name",
4378 "serviceName",
4379 "tags",
4380 ];
4381
4382 #[allow(clippy::enum_variant_names)]
4383 enum GeneratedField {
4384 Provider,
4385 ServiceName,
4386 Tags,
4387 }
4388 impl<'de> serde::Deserialize<'de> for GeneratedField {
4389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4390 where
4391 D: serde::Deserializer<'de>,
4392 {
4393 struct GeneratedVisitor;
4394
4395 impl serde::de::Visitor<'_> for GeneratedVisitor {
4396 type Value = GeneratedField;
4397
4398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4399 write!(formatter, "expected one of: {:?}", &FIELDS)
4400 }
4401
4402 #[allow(unused_variables)]
4403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4404 where
4405 E: serde::de::Error,
4406 {
4407 match value {
4408 "provider" => Ok(GeneratedField::Provider),
4409 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
4410 "tags" => Ok(GeneratedField::Tags),
4411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4412 }
4413 }
4414 }
4415 deserializer.deserialize_identifier(GeneratedVisitor)
4416 }
4417 }
4418 struct GeneratedVisitor;
4419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4420 type Value = create_connection_request::PrivateLink;
4421
4422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4423 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
4424 }
4425
4426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
4427 where
4428 V: serde::de::MapAccess<'de>,
4429 {
4430 let mut provider__ = None;
4431 let mut service_name__ = None;
4432 let mut tags__ = None;
4433 while let Some(k) = map_.next_key()? {
4434 match k {
4435 GeneratedField::Provider => {
4436 if provider__.is_some() {
4437 return Err(serde::de::Error::duplicate_field("provider"));
4438 }
4439 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
4440 }
4441 GeneratedField::ServiceName => {
4442 if service_name__.is_some() {
4443 return Err(serde::de::Error::duplicate_field("serviceName"));
4444 }
4445 service_name__ = Some(map_.next_value()?);
4446 }
4447 GeneratedField::Tags => {
4448 if tags__.is_some() {
4449 return Err(serde::de::Error::duplicate_field("tags"));
4450 }
4451 tags__ = map_.next_value()?;
4452 }
4453 }
4454 }
4455 Ok(create_connection_request::PrivateLink {
4456 provider: provider__.unwrap_or_default(),
4457 service_name: service_name__.unwrap_or_default(),
4458 tags: tags__,
4459 })
4460 }
4461 }
4462 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
4463 }
4464}
4465impl serde::Serialize for CreateConnectionResponse {
4466 #[allow(deprecated)]
4467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4468 where
4469 S: serde::Serializer,
4470 {
4471 use serde::ser::SerializeStruct;
4472 let mut len = 0;
4473 if self.version.is_some() {
4474 len += 1;
4475 }
4476 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
4477 if let Some(v) = self.version.as_ref() {
4478 struct_ser.serialize_field("version", v)?;
4479 }
4480 struct_ser.end()
4481 }
4482}
4483impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
4484 #[allow(deprecated)]
4485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4486 where
4487 D: serde::Deserializer<'de>,
4488 {
4489 const FIELDS: &[&str] = &[
4490 "version",
4491 ];
4492
4493 #[allow(clippy::enum_variant_names)]
4494 enum GeneratedField {
4495 Version,
4496 }
4497 impl<'de> serde::Deserialize<'de> for GeneratedField {
4498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4499 where
4500 D: serde::Deserializer<'de>,
4501 {
4502 struct GeneratedVisitor;
4503
4504 impl serde::de::Visitor<'_> for GeneratedVisitor {
4505 type Value = GeneratedField;
4506
4507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4508 write!(formatter, "expected one of: {:?}", &FIELDS)
4509 }
4510
4511 #[allow(unused_variables)]
4512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4513 where
4514 E: serde::de::Error,
4515 {
4516 match value {
4517 "version" => Ok(GeneratedField::Version),
4518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4519 }
4520 }
4521 }
4522 deserializer.deserialize_identifier(GeneratedVisitor)
4523 }
4524 }
4525 struct GeneratedVisitor;
4526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4527 type Value = CreateConnectionResponse;
4528
4529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4530 formatter.write_str("struct ddl_service.CreateConnectionResponse")
4531 }
4532
4533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
4534 where
4535 V: serde::de::MapAccess<'de>,
4536 {
4537 let mut version__ = None;
4538 while let Some(k) = map_.next_key()? {
4539 match k {
4540 GeneratedField::Version => {
4541 if version__.is_some() {
4542 return Err(serde::de::Error::duplicate_field("version"));
4543 }
4544 version__ = map_.next_value()?;
4545 }
4546 }
4547 }
4548 Ok(CreateConnectionResponse {
4549 version: version__,
4550 })
4551 }
4552 }
4553 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
4554 }
4555}
4556impl serde::Serialize for CreateDatabaseRequest {
4557 #[allow(deprecated)]
4558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4559 where
4560 S: serde::Serializer,
4561 {
4562 use serde::ser::SerializeStruct;
4563 let mut len = 0;
4564 if self.db.is_some() {
4565 len += 1;
4566 }
4567 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
4568 if let Some(v) = self.db.as_ref() {
4569 struct_ser.serialize_field("db", v)?;
4570 }
4571 struct_ser.end()
4572 }
4573}
4574impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
4575 #[allow(deprecated)]
4576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4577 where
4578 D: serde::Deserializer<'de>,
4579 {
4580 const FIELDS: &[&str] = &[
4581 "db",
4582 ];
4583
4584 #[allow(clippy::enum_variant_names)]
4585 enum GeneratedField {
4586 Db,
4587 }
4588 impl<'de> serde::Deserialize<'de> for GeneratedField {
4589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4590 where
4591 D: serde::Deserializer<'de>,
4592 {
4593 struct GeneratedVisitor;
4594
4595 impl serde::de::Visitor<'_> for GeneratedVisitor {
4596 type Value = GeneratedField;
4597
4598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4599 write!(formatter, "expected one of: {:?}", &FIELDS)
4600 }
4601
4602 #[allow(unused_variables)]
4603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4604 where
4605 E: serde::de::Error,
4606 {
4607 match value {
4608 "db" => Ok(GeneratedField::Db),
4609 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4610 }
4611 }
4612 }
4613 deserializer.deserialize_identifier(GeneratedVisitor)
4614 }
4615 }
4616 struct GeneratedVisitor;
4617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4618 type Value = CreateDatabaseRequest;
4619
4620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4621 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
4622 }
4623
4624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
4625 where
4626 V: serde::de::MapAccess<'de>,
4627 {
4628 let mut db__ = None;
4629 while let Some(k) = map_.next_key()? {
4630 match k {
4631 GeneratedField::Db => {
4632 if db__.is_some() {
4633 return Err(serde::de::Error::duplicate_field("db"));
4634 }
4635 db__ = map_.next_value()?;
4636 }
4637 }
4638 }
4639 Ok(CreateDatabaseRequest {
4640 db: db__,
4641 })
4642 }
4643 }
4644 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
4645 }
4646}
4647impl serde::Serialize for CreateDatabaseResponse {
4648 #[allow(deprecated)]
4649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4650 where
4651 S: serde::Serializer,
4652 {
4653 use serde::ser::SerializeStruct;
4654 let mut len = 0;
4655 if self.status.is_some() {
4656 len += 1;
4657 }
4658 if self.version.is_some() {
4659 len += 1;
4660 }
4661 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
4662 if let Some(v) = self.status.as_ref() {
4663 struct_ser.serialize_field("status", v)?;
4664 }
4665 if let Some(v) = self.version.as_ref() {
4666 struct_ser.serialize_field("version", v)?;
4667 }
4668 struct_ser.end()
4669 }
4670}
4671impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
4672 #[allow(deprecated)]
4673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4674 where
4675 D: serde::Deserializer<'de>,
4676 {
4677 const FIELDS: &[&str] = &[
4678 "status",
4679 "version",
4680 ];
4681
4682 #[allow(clippy::enum_variant_names)]
4683 enum GeneratedField {
4684 Status,
4685 Version,
4686 }
4687 impl<'de> serde::Deserialize<'de> for GeneratedField {
4688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4689 where
4690 D: serde::Deserializer<'de>,
4691 {
4692 struct GeneratedVisitor;
4693
4694 impl serde::de::Visitor<'_> for GeneratedVisitor {
4695 type Value = GeneratedField;
4696
4697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4698 write!(formatter, "expected one of: {:?}", &FIELDS)
4699 }
4700
4701 #[allow(unused_variables)]
4702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4703 where
4704 E: serde::de::Error,
4705 {
4706 match value {
4707 "status" => Ok(GeneratedField::Status),
4708 "version" => Ok(GeneratedField::Version),
4709 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4710 }
4711 }
4712 }
4713 deserializer.deserialize_identifier(GeneratedVisitor)
4714 }
4715 }
4716 struct GeneratedVisitor;
4717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4718 type Value = CreateDatabaseResponse;
4719
4720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4721 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
4722 }
4723
4724 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
4725 where
4726 V: serde::de::MapAccess<'de>,
4727 {
4728 let mut status__ = None;
4729 let mut version__ = None;
4730 while let Some(k) = map_.next_key()? {
4731 match k {
4732 GeneratedField::Status => {
4733 if status__.is_some() {
4734 return Err(serde::de::Error::duplicate_field("status"));
4735 }
4736 status__ = map_.next_value()?;
4737 }
4738 GeneratedField::Version => {
4739 if version__.is_some() {
4740 return Err(serde::de::Error::duplicate_field("version"));
4741 }
4742 version__ = map_.next_value()?;
4743 }
4744 }
4745 }
4746 Ok(CreateDatabaseResponse {
4747 status: status__,
4748 version: version__,
4749 })
4750 }
4751 }
4752 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
4753 }
4754}
4755impl serde::Serialize for CreateFunctionRequest {
4756 #[allow(deprecated)]
4757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4758 where
4759 S: serde::Serializer,
4760 {
4761 use serde::ser::SerializeStruct;
4762 let mut len = 0;
4763 if self.function.is_some() {
4764 len += 1;
4765 }
4766 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
4767 if let Some(v) = self.function.as_ref() {
4768 struct_ser.serialize_field("function", v)?;
4769 }
4770 struct_ser.end()
4771 }
4772}
4773impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
4774 #[allow(deprecated)]
4775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4776 where
4777 D: serde::Deserializer<'de>,
4778 {
4779 const FIELDS: &[&str] = &[
4780 "function",
4781 ];
4782
4783 #[allow(clippy::enum_variant_names)]
4784 enum GeneratedField {
4785 Function,
4786 }
4787 impl<'de> serde::Deserialize<'de> for GeneratedField {
4788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4789 where
4790 D: serde::Deserializer<'de>,
4791 {
4792 struct GeneratedVisitor;
4793
4794 impl serde::de::Visitor<'_> for GeneratedVisitor {
4795 type Value = GeneratedField;
4796
4797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4798 write!(formatter, "expected one of: {:?}", &FIELDS)
4799 }
4800
4801 #[allow(unused_variables)]
4802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4803 where
4804 E: serde::de::Error,
4805 {
4806 match value {
4807 "function" => Ok(GeneratedField::Function),
4808 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4809 }
4810 }
4811 }
4812 deserializer.deserialize_identifier(GeneratedVisitor)
4813 }
4814 }
4815 struct GeneratedVisitor;
4816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4817 type Value = CreateFunctionRequest;
4818
4819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4820 formatter.write_str("struct ddl_service.CreateFunctionRequest")
4821 }
4822
4823 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
4824 where
4825 V: serde::de::MapAccess<'de>,
4826 {
4827 let mut function__ = None;
4828 while let Some(k) = map_.next_key()? {
4829 match k {
4830 GeneratedField::Function => {
4831 if function__.is_some() {
4832 return Err(serde::de::Error::duplicate_field("function"));
4833 }
4834 function__ = map_.next_value()?;
4835 }
4836 }
4837 }
4838 Ok(CreateFunctionRequest {
4839 function: function__,
4840 })
4841 }
4842 }
4843 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
4844 }
4845}
4846impl serde::Serialize for CreateFunctionResponse {
4847 #[allow(deprecated)]
4848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4849 where
4850 S: serde::Serializer,
4851 {
4852 use serde::ser::SerializeStruct;
4853 let mut len = 0;
4854 if self.status.is_some() {
4855 len += 1;
4856 }
4857 if self.version.is_some() {
4858 len += 1;
4859 }
4860 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
4861 if let Some(v) = self.status.as_ref() {
4862 struct_ser.serialize_field("status", v)?;
4863 }
4864 if let Some(v) = self.version.as_ref() {
4865 struct_ser.serialize_field("version", v)?;
4866 }
4867 struct_ser.end()
4868 }
4869}
4870impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
4871 #[allow(deprecated)]
4872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4873 where
4874 D: serde::Deserializer<'de>,
4875 {
4876 const FIELDS: &[&str] = &[
4877 "status",
4878 "version",
4879 ];
4880
4881 #[allow(clippy::enum_variant_names)]
4882 enum GeneratedField {
4883 Status,
4884 Version,
4885 }
4886 impl<'de> serde::Deserialize<'de> for GeneratedField {
4887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4888 where
4889 D: serde::Deserializer<'de>,
4890 {
4891 struct GeneratedVisitor;
4892
4893 impl serde::de::Visitor<'_> for GeneratedVisitor {
4894 type Value = GeneratedField;
4895
4896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4897 write!(formatter, "expected one of: {:?}", &FIELDS)
4898 }
4899
4900 #[allow(unused_variables)]
4901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4902 where
4903 E: serde::de::Error,
4904 {
4905 match value {
4906 "status" => Ok(GeneratedField::Status),
4907 "version" => Ok(GeneratedField::Version),
4908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4909 }
4910 }
4911 }
4912 deserializer.deserialize_identifier(GeneratedVisitor)
4913 }
4914 }
4915 struct GeneratedVisitor;
4916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4917 type Value = CreateFunctionResponse;
4918
4919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4920 formatter.write_str("struct ddl_service.CreateFunctionResponse")
4921 }
4922
4923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
4924 where
4925 V: serde::de::MapAccess<'de>,
4926 {
4927 let mut status__ = None;
4928 let mut version__ = None;
4929 while let Some(k) = map_.next_key()? {
4930 match k {
4931 GeneratedField::Status => {
4932 if status__.is_some() {
4933 return Err(serde::de::Error::duplicate_field("status"));
4934 }
4935 status__ = map_.next_value()?;
4936 }
4937 GeneratedField::Version => {
4938 if version__.is_some() {
4939 return Err(serde::de::Error::duplicate_field("version"));
4940 }
4941 version__ = map_.next_value()?;
4942 }
4943 }
4944 }
4945 Ok(CreateFunctionResponse {
4946 status: status__,
4947 version: version__,
4948 })
4949 }
4950 }
4951 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
4952 }
4953}
4954impl serde::Serialize for CreateIcebergTableRequest {
4955 #[allow(deprecated)]
4956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4957 where
4958 S: serde::Serializer,
4959 {
4960 use serde::ser::SerializeStruct;
4961 let mut len = 0;
4962 if self.table_info.is_some() {
4963 len += 1;
4964 }
4965 if self.sink_info.is_some() {
4966 len += 1;
4967 }
4968 if self.iceberg_source.is_some() {
4969 len += 1;
4970 }
4971 if self.if_not_exists {
4972 len += 1;
4973 }
4974 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
4975 if let Some(v) = self.table_info.as_ref() {
4976 struct_ser.serialize_field("tableInfo", v)?;
4977 }
4978 if let Some(v) = self.sink_info.as_ref() {
4979 struct_ser.serialize_field("sinkInfo", v)?;
4980 }
4981 if let Some(v) = self.iceberg_source.as_ref() {
4982 struct_ser.serialize_field("icebergSource", v)?;
4983 }
4984 if self.if_not_exists {
4985 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4986 }
4987 struct_ser.end()
4988 }
4989}
4990impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
4991 #[allow(deprecated)]
4992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4993 where
4994 D: serde::Deserializer<'de>,
4995 {
4996 const FIELDS: &[&str] = &[
4997 "table_info",
4998 "tableInfo",
4999 "sink_info",
5000 "sinkInfo",
5001 "iceberg_source",
5002 "icebergSource",
5003 "if_not_exists",
5004 "ifNotExists",
5005 ];
5006
5007 #[allow(clippy::enum_variant_names)]
5008 enum GeneratedField {
5009 TableInfo,
5010 SinkInfo,
5011 IcebergSource,
5012 IfNotExists,
5013 }
5014 impl<'de> serde::Deserialize<'de> for GeneratedField {
5015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5016 where
5017 D: serde::Deserializer<'de>,
5018 {
5019 struct GeneratedVisitor;
5020
5021 impl serde::de::Visitor<'_> for GeneratedVisitor {
5022 type Value = GeneratedField;
5023
5024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5025 write!(formatter, "expected one of: {:?}", &FIELDS)
5026 }
5027
5028 #[allow(unused_variables)]
5029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5030 where
5031 E: serde::de::Error,
5032 {
5033 match value {
5034 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
5035 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
5036 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
5037 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5039 }
5040 }
5041 }
5042 deserializer.deserialize_identifier(GeneratedVisitor)
5043 }
5044 }
5045 struct GeneratedVisitor;
5046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5047 type Value = CreateIcebergTableRequest;
5048
5049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5050 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
5051 }
5052
5053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
5054 where
5055 V: serde::de::MapAccess<'de>,
5056 {
5057 let mut table_info__ = None;
5058 let mut sink_info__ = None;
5059 let mut iceberg_source__ = None;
5060 let mut if_not_exists__ = None;
5061 while let Some(k) = map_.next_key()? {
5062 match k {
5063 GeneratedField::TableInfo => {
5064 if table_info__.is_some() {
5065 return Err(serde::de::Error::duplicate_field("tableInfo"));
5066 }
5067 table_info__ = map_.next_value()?;
5068 }
5069 GeneratedField::SinkInfo => {
5070 if sink_info__.is_some() {
5071 return Err(serde::de::Error::duplicate_field("sinkInfo"));
5072 }
5073 sink_info__ = map_.next_value()?;
5074 }
5075 GeneratedField::IcebergSource => {
5076 if iceberg_source__.is_some() {
5077 return Err(serde::de::Error::duplicate_field("icebergSource"));
5078 }
5079 iceberg_source__ = map_.next_value()?;
5080 }
5081 GeneratedField::IfNotExists => {
5082 if if_not_exists__.is_some() {
5083 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5084 }
5085 if_not_exists__ = Some(map_.next_value()?);
5086 }
5087 }
5088 }
5089 Ok(CreateIcebergTableRequest {
5090 table_info: table_info__,
5091 sink_info: sink_info__,
5092 iceberg_source: iceberg_source__,
5093 if_not_exists: if_not_exists__.unwrap_or_default(),
5094 })
5095 }
5096 }
5097 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
5098 }
5099}
5100impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
5101 #[allow(deprecated)]
5102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5103 where
5104 S: serde::Serializer,
5105 {
5106 use serde::ser::SerializeStruct;
5107 let mut len = 0;
5108 if self.sink.is_some() {
5109 len += 1;
5110 }
5111 if self.fragment_graph.is_some() {
5112 len += 1;
5113 }
5114 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
5115 if let Some(v) = self.sink.as_ref() {
5116 struct_ser.serialize_field("sink", v)?;
5117 }
5118 if let Some(v) = self.fragment_graph.as_ref() {
5119 struct_ser.serialize_field("fragmentGraph", v)?;
5120 }
5121 struct_ser.end()
5122 }
5123}
5124impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
5125 #[allow(deprecated)]
5126 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5127 where
5128 D: serde::Deserializer<'de>,
5129 {
5130 const FIELDS: &[&str] = &[
5131 "sink",
5132 "fragment_graph",
5133 "fragmentGraph",
5134 ];
5135
5136 #[allow(clippy::enum_variant_names)]
5137 enum GeneratedField {
5138 Sink,
5139 FragmentGraph,
5140 }
5141 impl<'de> serde::Deserialize<'de> for GeneratedField {
5142 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5143 where
5144 D: serde::Deserializer<'de>,
5145 {
5146 struct GeneratedVisitor;
5147
5148 impl serde::de::Visitor<'_> for GeneratedVisitor {
5149 type Value = GeneratedField;
5150
5151 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5152 write!(formatter, "expected one of: {:?}", &FIELDS)
5153 }
5154
5155 #[allow(unused_variables)]
5156 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5157 where
5158 E: serde::de::Error,
5159 {
5160 match value {
5161 "sink" => Ok(GeneratedField::Sink),
5162 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5163 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5164 }
5165 }
5166 }
5167 deserializer.deserialize_identifier(GeneratedVisitor)
5168 }
5169 }
5170 struct GeneratedVisitor;
5171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5172 type Value = create_iceberg_table_request::SinkJobInfo;
5173
5174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5175 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
5176 }
5177
5178 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
5179 where
5180 V: serde::de::MapAccess<'de>,
5181 {
5182 let mut sink__ = None;
5183 let mut fragment_graph__ = None;
5184 while let Some(k) = map_.next_key()? {
5185 match k {
5186 GeneratedField::Sink => {
5187 if sink__.is_some() {
5188 return Err(serde::de::Error::duplicate_field("sink"));
5189 }
5190 sink__ = map_.next_value()?;
5191 }
5192 GeneratedField::FragmentGraph => {
5193 if fragment_graph__.is_some() {
5194 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5195 }
5196 fragment_graph__ = map_.next_value()?;
5197 }
5198 }
5199 }
5200 Ok(create_iceberg_table_request::SinkJobInfo {
5201 sink: sink__,
5202 fragment_graph: fragment_graph__,
5203 })
5204 }
5205 }
5206 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
5207 }
5208}
5209impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
5210 #[allow(deprecated)]
5211 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5212 where
5213 S: serde::Serializer,
5214 {
5215 use serde::ser::SerializeStruct;
5216 let mut len = 0;
5217 if self.source.is_some() {
5218 len += 1;
5219 }
5220 if self.table.is_some() {
5221 len += 1;
5222 }
5223 if self.fragment_graph.is_some() {
5224 len += 1;
5225 }
5226 if self.job_type != 0 {
5227 len += 1;
5228 }
5229 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
5230 if let Some(v) = self.source.as_ref() {
5231 struct_ser.serialize_field("source", v)?;
5232 }
5233 if let Some(v) = self.table.as_ref() {
5234 struct_ser.serialize_field("table", v)?;
5235 }
5236 if let Some(v) = self.fragment_graph.as_ref() {
5237 struct_ser.serialize_field("fragmentGraph", v)?;
5238 }
5239 if self.job_type != 0 {
5240 let v = TableJobType::try_from(self.job_type)
5241 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
5242 struct_ser.serialize_field("jobType", &v)?;
5243 }
5244 struct_ser.end()
5245 }
5246}
5247impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
5248 #[allow(deprecated)]
5249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5250 where
5251 D: serde::Deserializer<'de>,
5252 {
5253 const FIELDS: &[&str] = &[
5254 "source",
5255 "table",
5256 "fragment_graph",
5257 "fragmentGraph",
5258 "job_type",
5259 "jobType",
5260 ];
5261
5262 #[allow(clippy::enum_variant_names)]
5263 enum GeneratedField {
5264 Source,
5265 Table,
5266 FragmentGraph,
5267 JobType,
5268 }
5269 impl<'de> serde::Deserialize<'de> for GeneratedField {
5270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5271 where
5272 D: serde::Deserializer<'de>,
5273 {
5274 struct GeneratedVisitor;
5275
5276 impl serde::de::Visitor<'_> for GeneratedVisitor {
5277 type Value = GeneratedField;
5278
5279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5280 write!(formatter, "expected one of: {:?}", &FIELDS)
5281 }
5282
5283 #[allow(unused_variables)]
5284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5285 where
5286 E: serde::de::Error,
5287 {
5288 match value {
5289 "source" => Ok(GeneratedField::Source),
5290 "table" => Ok(GeneratedField::Table),
5291 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5292 "jobType" | "job_type" => Ok(GeneratedField::JobType),
5293 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5294 }
5295 }
5296 }
5297 deserializer.deserialize_identifier(GeneratedVisitor)
5298 }
5299 }
5300 struct GeneratedVisitor;
5301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5302 type Value = create_iceberg_table_request::TableJobInfo;
5303
5304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5305 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
5306 }
5307
5308 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
5309 where
5310 V: serde::de::MapAccess<'de>,
5311 {
5312 let mut source__ = None;
5313 let mut table__ = None;
5314 let mut fragment_graph__ = None;
5315 let mut job_type__ = None;
5316 while let Some(k) = map_.next_key()? {
5317 match k {
5318 GeneratedField::Source => {
5319 if source__.is_some() {
5320 return Err(serde::de::Error::duplicate_field("source"));
5321 }
5322 source__ = map_.next_value()?;
5323 }
5324 GeneratedField::Table => {
5325 if table__.is_some() {
5326 return Err(serde::de::Error::duplicate_field("table"));
5327 }
5328 table__ = map_.next_value()?;
5329 }
5330 GeneratedField::FragmentGraph => {
5331 if fragment_graph__.is_some() {
5332 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5333 }
5334 fragment_graph__ = map_.next_value()?;
5335 }
5336 GeneratedField::JobType => {
5337 if job_type__.is_some() {
5338 return Err(serde::de::Error::duplicate_field("jobType"));
5339 }
5340 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
5341 }
5342 }
5343 }
5344 Ok(create_iceberg_table_request::TableJobInfo {
5345 source: source__,
5346 table: table__,
5347 fragment_graph: fragment_graph__,
5348 job_type: job_type__.unwrap_or_default(),
5349 })
5350 }
5351 }
5352 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
5353 }
5354}
5355impl serde::Serialize for CreateIcebergTableResponse {
5356 #[allow(deprecated)]
5357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5358 where
5359 S: serde::Serializer,
5360 {
5361 use serde::ser::SerializeStruct;
5362 let mut len = 0;
5363 if self.status.is_some() {
5364 len += 1;
5365 }
5366 if self.version.is_some() {
5367 len += 1;
5368 }
5369 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
5370 if let Some(v) = self.status.as_ref() {
5371 struct_ser.serialize_field("status", v)?;
5372 }
5373 if let Some(v) = self.version.as_ref() {
5374 struct_ser.serialize_field("version", v)?;
5375 }
5376 struct_ser.end()
5377 }
5378}
5379impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
5380 #[allow(deprecated)]
5381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5382 where
5383 D: serde::Deserializer<'de>,
5384 {
5385 const FIELDS: &[&str] = &[
5386 "status",
5387 "version",
5388 ];
5389
5390 #[allow(clippy::enum_variant_names)]
5391 enum GeneratedField {
5392 Status,
5393 Version,
5394 }
5395 impl<'de> serde::Deserialize<'de> for GeneratedField {
5396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5397 where
5398 D: serde::Deserializer<'de>,
5399 {
5400 struct GeneratedVisitor;
5401
5402 impl serde::de::Visitor<'_> for GeneratedVisitor {
5403 type Value = GeneratedField;
5404
5405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5406 write!(formatter, "expected one of: {:?}", &FIELDS)
5407 }
5408
5409 #[allow(unused_variables)]
5410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5411 where
5412 E: serde::de::Error,
5413 {
5414 match value {
5415 "status" => Ok(GeneratedField::Status),
5416 "version" => Ok(GeneratedField::Version),
5417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5418 }
5419 }
5420 }
5421 deserializer.deserialize_identifier(GeneratedVisitor)
5422 }
5423 }
5424 struct GeneratedVisitor;
5425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5426 type Value = CreateIcebergTableResponse;
5427
5428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5429 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
5430 }
5431
5432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
5433 where
5434 V: serde::de::MapAccess<'de>,
5435 {
5436 let mut status__ = None;
5437 let mut version__ = None;
5438 while let Some(k) = map_.next_key()? {
5439 match k {
5440 GeneratedField::Status => {
5441 if status__.is_some() {
5442 return Err(serde::de::Error::duplicate_field("status"));
5443 }
5444 status__ = map_.next_value()?;
5445 }
5446 GeneratedField::Version => {
5447 if version__.is_some() {
5448 return Err(serde::de::Error::duplicate_field("version"));
5449 }
5450 version__ = map_.next_value()?;
5451 }
5452 }
5453 }
5454 Ok(CreateIcebergTableResponse {
5455 status: status__,
5456 version: version__,
5457 })
5458 }
5459 }
5460 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
5461 }
5462}
5463impl serde::Serialize for CreateIndexRequest {
5464 #[allow(deprecated)]
5465 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5466 where
5467 S: serde::Serializer,
5468 {
5469 use serde::ser::SerializeStruct;
5470 let mut len = 0;
5471 if self.index.is_some() {
5472 len += 1;
5473 }
5474 if self.index_table.is_some() {
5475 len += 1;
5476 }
5477 if self.fragment_graph.is_some() {
5478 len += 1;
5479 }
5480 if self.if_not_exists {
5481 len += 1;
5482 }
5483 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
5484 if let Some(v) = self.index.as_ref() {
5485 struct_ser.serialize_field("index", v)?;
5486 }
5487 if let Some(v) = self.index_table.as_ref() {
5488 struct_ser.serialize_field("indexTable", v)?;
5489 }
5490 if let Some(v) = self.fragment_graph.as_ref() {
5491 struct_ser.serialize_field("fragmentGraph", v)?;
5492 }
5493 if self.if_not_exists {
5494 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5495 }
5496 struct_ser.end()
5497 }
5498}
5499impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
5500 #[allow(deprecated)]
5501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5502 where
5503 D: serde::Deserializer<'de>,
5504 {
5505 const FIELDS: &[&str] = &[
5506 "index",
5507 "index_table",
5508 "indexTable",
5509 "fragment_graph",
5510 "fragmentGraph",
5511 "if_not_exists",
5512 "ifNotExists",
5513 ];
5514
5515 #[allow(clippy::enum_variant_names)]
5516 enum GeneratedField {
5517 Index,
5518 IndexTable,
5519 FragmentGraph,
5520 IfNotExists,
5521 }
5522 impl<'de> serde::Deserialize<'de> for GeneratedField {
5523 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5524 where
5525 D: serde::Deserializer<'de>,
5526 {
5527 struct GeneratedVisitor;
5528
5529 impl serde::de::Visitor<'_> for GeneratedVisitor {
5530 type Value = GeneratedField;
5531
5532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5533 write!(formatter, "expected one of: {:?}", &FIELDS)
5534 }
5535
5536 #[allow(unused_variables)]
5537 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5538 where
5539 E: serde::de::Error,
5540 {
5541 match value {
5542 "index" => Ok(GeneratedField::Index),
5543 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
5544 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5545 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5546 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5547 }
5548 }
5549 }
5550 deserializer.deserialize_identifier(GeneratedVisitor)
5551 }
5552 }
5553 struct GeneratedVisitor;
5554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5555 type Value = CreateIndexRequest;
5556
5557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5558 formatter.write_str("struct ddl_service.CreateIndexRequest")
5559 }
5560
5561 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
5562 where
5563 V: serde::de::MapAccess<'de>,
5564 {
5565 let mut index__ = None;
5566 let mut index_table__ = None;
5567 let mut fragment_graph__ = None;
5568 let mut if_not_exists__ = None;
5569 while let Some(k) = map_.next_key()? {
5570 match k {
5571 GeneratedField::Index => {
5572 if index__.is_some() {
5573 return Err(serde::de::Error::duplicate_field("index"));
5574 }
5575 index__ = map_.next_value()?;
5576 }
5577 GeneratedField::IndexTable => {
5578 if index_table__.is_some() {
5579 return Err(serde::de::Error::duplicate_field("indexTable"));
5580 }
5581 index_table__ = map_.next_value()?;
5582 }
5583 GeneratedField::FragmentGraph => {
5584 if fragment_graph__.is_some() {
5585 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5586 }
5587 fragment_graph__ = map_.next_value()?;
5588 }
5589 GeneratedField::IfNotExists => {
5590 if if_not_exists__.is_some() {
5591 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5592 }
5593 if_not_exists__ = Some(map_.next_value()?);
5594 }
5595 }
5596 }
5597 Ok(CreateIndexRequest {
5598 index: index__,
5599 index_table: index_table__,
5600 fragment_graph: fragment_graph__,
5601 if_not_exists: if_not_exists__.unwrap_or_default(),
5602 })
5603 }
5604 }
5605 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
5606 }
5607}
5608impl serde::Serialize for CreateIndexResponse {
5609 #[allow(deprecated)]
5610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5611 where
5612 S: serde::Serializer,
5613 {
5614 use serde::ser::SerializeStruct;
5615 let mut len = 0;
5616 if self.status.is_some() {
5617 len += 1;
5618 }
5619 if self.version.is_some() {
5620 len += 1;
5621 }
5622 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
5623 if let Some(v) = self.status.as_ref() {
5624 struct_ser.serialize_field("status", v)?;
5625 }
5626 if let Some(v) = self.version.as_ref() {
5627 struct_ser.serialize_field("version", v)?;
5628 }
5629 struct_ser.end()
5630 }
5631}
5632impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
5633 #[allow(deprecated)]
5634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5635 where
5636 D: serde::Deserializer<'de>,
5637 {
5638 const FIELDS: &[&str] = &[
5639 "status",
5640 "version",
5641 ];
5642
5643 #[allow(clippy::enum_variant_names)]
5644 enum GeneratedField {
5645 Status,
5646 Version,
5647 }
5648 impl<'de> serde::Deserialize<'de> for GeneratedField {
5649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5650 where
5651 D: serde::Deserializer<'de>,
5652 {
5653 struct GeneratedVisitor;
5654
5655 impl serde::de::Visitor<'_> for GeneratedVisitor {
5656 type Value = GeneratedField;
5657
5658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5659 write!(formatter, "expected one of: {:?}", &FIELDS)
5660 }
5661
5662 #[allow(unused_variables)]
5663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5664 where
5665 E: serde::de::Error,
5666 {
5667 match value {
5668 "status" => Ok(GeneratedField::Status),
5669 "version" => Ok(GeneratedField::Version),
5670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5671 }
5672 }
5673 }
5674 deserializer.deserialize_identifier(GeneratedVisitor)
5675 }
5676 }
5677 struct GeneratedVisitor;
5678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5679 type Value = CreateIndexResponse;
5680
5681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5682 formatter.write_str("struct ddl_service.CreateIndexResponse")
5683 }
5684
5685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
5686 where
5687 V: serde::de::MapAccess<'de>,
5688 {
5689 let mut status__ = None;
5690 let mut version__ = None;
5691 while let Some(k) = map_.next_key()? {
5692 match k {
5693 GeneratedField::Status => {
5694 if status__.is_some() {
5695 return Err(serde::de::Error::duplicate_field("status"));
5696 }
5697 status__ = map_.next_value()?;
5698 }
5699 GeneratedField::Version => {
5700 if version__.is_some() {
5701 return Err(serde::de::Error::duplicate_field("version"));
5702 }
5703 version__ = map_.next_value()?;
5704 }
5705 }
5706 }
5707 Ok(CreateIndexResponse {
5708 status: status__,
5709 version: version__,
5710 })
5711 }
5712 }
5713 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
5714 }
5715}
5716impl serde::Serialize for CreateMaterializedViewRequest {
5717 #[allow(deprecated)]
5718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5719 where
5720 S: serde::Serializer,
5721 {
5722 use serde::ser::SerializeStruct;
5723 let mut len = 0;
5724 if self.materialized_view.is_some() {
5725 len += 1;
5726 }
5727 if self.fragment_graph.is_some() {
5728 len += 1;
5729 }
5730 if self.resource_type.is_some() {
5731 len += 1;
5732 }
5733 if !self.dependencies.is_empty() {
5734 len += 1;
5735 }
5736 if self.if_not_exists {
5737 len += 1;
5738 }
5739 if self.refresh_interval_sec.is_some() {
5740 len += 1;
5741 }
5742 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
5743 if let Some(v) = self.materialized_view.as_ref() {
5744 struct_ser.serialize_field("materializedView", v)?;
5745 }
5746 if let Some(v) = self.fragment_graph.as_ref() {
5747 struct_ser.serialize_field("fragmentGraph", v)?;
5748 }
5749 if let Some(v) = self.resource_type.as_ref() {
5750 struct_ser.serialize_field("resourceType", v)?;
5751 }
5752 if !self.dependencies.is_empty() {
5753 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5754 }
5755 if self.if_not_exists {
5756 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5757 }
5758 if let Some(v) = self.refresh_interval_sec.as_ref() {
5759 #[allow(clippy::needless_borrow)]
5760 #[allow(clippy::needless_borrows_for_generic_args)]
5761 struct_ser.serialize_field("refreshIntervalSec", ToString::to_string(&v).as_str())?;
5762 }
5763 struct_ser.end()
5764 }
5765}
5766impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
5767 #[allow(deprecated)]
5768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5769 where
5770 D: serde::Deserializer<'de>,
5771 {
5772 const FIELDS: &[&str] = &[
5773 "materialized_view",
5774 "materializedView",
5775 "fragment_graph",
5776 "fragmentGraph",
5777 "resource_type",
5778 "resourceType",
5779 "dependencies",
5780 "if_not_exists",
5781 "ifNotExists",
5782 "refresh_interval_sec",
5783 "refreshIntervalSec",
5784 ];
5785
5786 #[allow(clippy::enum_variant_names)]
5787 enum GeneratedField {
5788 MaterializedView,
5789 FragmentGraph,
5790 ResourceType,
5791 Dependencies,
5792 IfNotExists,
5793 RefreshIntervalSec,
5794 }
5795 impl<'de> serde::Deserialize<'de> for GeneratedField {
5796 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5797 where
5798 D: serde::Deserializer<'de>,
5799 {
5800 struct GeneratedVisitor;
5801
5802 impl serde::de::Visitor<'_> for GeneratedVisitor {
5803 type Value = GeneratedField;
5804
5805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5806 write!(formatter, "expected one of: {:?}", &FIELDS)
5807 }
5808
5809 #[allow(unused_variables)]
5810 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5811 where
5812 E: serde::de::Error,
5813 {
5814 match value {
5815 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5816 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5817 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
5818 "dependencies" => Ok(GeneratedField::Dependencies),
5819 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5820 "refreshIntervalSec" | "refresh_interval_sec" => Ok(GeneratedField::RefreshIntervalSec),
5821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5822 }
5823 }
5824 }
5825 deserializer.deserialize_identifier(GeneratedVisitor)
5826 }
5827 }
5828 struct GeneratedVisitor;
5829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5830 type Value = CreateMaterializedViewRequest;
5831
5832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5833 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
5834 }
5835
5836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
5837 where
5838 V: serde::de::MapAccess<'de>,
5839 {
5840 let mut materialized_view__ = None;
5841 let mut fragment_graph__ = None;
5842 let mut resource_type__ = None;
5843 let mut dependencies__ = None;
5844 let mut if_not_exists__ = None;
5845 let mut refresh_interval_sec__ = None;
5846 while let Some(k) = map_.next_key()? {
5847 match k {
5848 GeneratedField::MaterializedView => {
5849 if materialized_view__.is_some() {
5850 return Err(serde::de::Error::duplicate_field("materializedView"));
5851 }
5852 materialized_view__ = map_.next_value()?;
5853 }
5854 GeneratedField::FragmentGraph => {
5855 if fragment_graph__.is_some() {
5856 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5857 }
5858 fragment_graph__ = map_.next_value()?;
5859 }
5860 GeneratedField::ResourceType => {
5861 if resource_type__.is_some() {
5862 return Err(serde::de::Error::duplicate_field("resourceType"));
5863 }
5864 resource_type__ = map_.next_value()?;
5865 }
5866 GeneratedField::Dependencies => {
5867 if dependencies__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("dependencies"));
5869 }
5870 dependencies__ =
5871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5872 .into_iter().map(|x| x.0).collect())
5873 ;
5874 }
5875 GeneratedField::IfNotExists => {
5876 if if_not_exists__.is_some() {
5877 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5878 }
5879 if_not_exists__ = Some(map_.next_value()?);
5880 }
5881 GeneratedField::RefreshIntervalSec => {
5882 if refresh_interval_sec__.is_some() {
5883 return Err(serde::de::Error::duplicate_field("refreshIntervalSec"));
5884 }
5885 refresh_interval_sec__ =
5886 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5887 ;
5888 }
5889 }
5890 }
5891 Ok(CreateMaterializedViewRequest {
5892 materialized_view: materialized_view__,
5893 fragment_graph: fragment_graph__,
5894 resource_type: resource_type__,
5895 dependencies: dependencies__.unwrap_or_default(),
5896 if_not_exists: if_not_exists__.unwrap_or_default(),
5897 refresh_interval_sec: refresh_interval_sec__,
5898 })
5899 }
5900 }
5901 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
5902 }
5903}
5904impl serde::Serialize for CreateMaterializedViewResponse {
5905 #[allow(deprecated)]
5906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5907 where
5908 S: serde::Serializer,
5909 {
5910 use serde::ser::SerializeStruct;
5911 let mut len = 0;
5912 if self.status.is_some() {
5913 len += 1;
5914 }
5915 if self.version.is_some() {
5916 len += 1;
5917 }
5918 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
5919 if let Some(v) = self.status.as_ref() {
5920 struct_ser.serialize_field("status", v)?;
5921 }
5922 if let Some(v) = self.version.as_ref() {
5923 struct_ser.serialize_field("version", v)?;
5924 }
5925 struct_ser.end()
5926 }
5927}
5928impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
5929 #[allow(deprecated)]
5930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5931 where
5932 D: serde::Deserializer<'de>,
5933 {
5934 const FIELDS: &[&str] = &[
5935 "status",
5936 "version",
5937 ];
5938
5939 #[allow(clippy::enum_variant_names)]
5940 enum GeneratedField {
5941 Status,
5942 Version,
5943 }
5944 impl<'de> serde::Deserialize<'de> for GeneratedField {
5945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5946 where
5947 D: serde::Deserializer<'de>,
5948 {
5949 struct GeneratedVisitor;
5950
5951 impl serde::de::Visitor<'_> for GeneratedVisitor {
5952 type Value = GeneratedField;
5953
5954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5955 write!(formatter, "expected one of: {:?}", &FIELDS)
5956 }
5957
5958 #[allow(unused_variables)]
5959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5960 where
5961 E: serde::de::Error,
5962 {
5963 match value {
5964 "status" => Ok(GeneratedField::Status),
5965 "version" => Ok(GeneratedField::Version),
5966 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5967 }
5968 }
5969 }
5970 deserializer.deserialize_identifier(GeneratedVisitor)
5971 }
5972 }
5973 struct GeneratedVisitor;
5974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5975 type Value = CreateMaterializedViewResponse;
5976
5977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5978 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
5979 }
5980
5981 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
5982 where
5983 V: serde::de::MapAccess<'de>,
5984 {
5985 let mut status__ = None;
5986 let mut version__ = None;
5987 while let Some(k) = map_.next_key()? {
5988 match k {
5989 GeneratedField::Status => {
5990 if status__.is_some() {
5991 return Err(serde::de::Error::duplicate_field("status"));
5992 }
5993 status__ = map_.next_value()?;
5994 }
5995 GeneratedField::Version => {
5996 if version__.is_some() {
5997 return Err(serde::de::Error::duplicate_field("version"));
5998 }
5999 version__ = map_.next_value()?;
6000 }
6001 }
6002 }
6003 Ok(CreateMaterializedViewResponse {
6004 status: status__,
6005 version: version__,
6006 })
6007 }
6008 }
6009 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
6010 }
6011}
6012impl serde::Serialize for CreateSchemaRequest {
6013 #[allow(deprecated)]
6014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6015 where
6016 S: serde::Serializer,
6017 {
6018 use serde::ser::SerializeStruct;
6019 let mut len = 0;
6020 if self.schema.is_some() {
6021 len += 1;
6022 }
6023 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
6024 if let Some(v) = self.schema.as_ref() {
6025 struct_ser.serialize_field("schema", v)?;
6026 }
6027 struct_ser.end()
6028 }
6029}
6030impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
6031 #[allow(deprecated)]
6032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6033 where
6034 D: serde::Deserializer<'de>,
6035 {
6036 const FIELDS: &[&str] = &[
6037 "schema",
6038 ];
6039
6040 #[allow(clippy::enum_variant_names)]
6041 enum GeneratedField {
6042 Schema,
6043 }
6044 impl<'de> serde::Deserialize<'de> for GeneratedField {
6045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6046 where
6047 D: serde::Deserializer<'de>,
6048 {
6049 struct GeneratedVisitor;
6050
6051 impl serde::de::Visitor<'_> for GeneratedVisitor {
6052 type Value = GeneratedField;
6053
6054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6055 write!(formatter, "expected one of: {:?}", &FIELDS)
6056 }
6057
6058 #[allow(unused_variables)]
6059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6060 where
6061 E: serde::de::Error,
6062 {
6063 match value {
6064 "schema" => Ok(GeneratedField::Schema),
6065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6066 }
6067 }
6068 }
6069 deserializer.deserialize_identifier(GeneratedVisitor)
6070 }
6071 }
6072 struct GeneratedVisitor;
6073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6074 type Value = CreateSchemaRequest;
6075
6076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6077 formatter.write_str("struct ddl_service.CreateSchemaRequest")
6078 }
6079
6080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
6081 where
6082 V: serde::de::MapAccess<'de>,
6083 {
6084 let mut schema__ = None;
6085 while let Some(k) = map_.next_key()? {
6086 match k {
6087 GeneratedField::Schema => {
6088 if schema__.is_some() {
6089 return Err(serde::de::Error::duplicate_field("schema"));
6090 }
6091 schema__ = map_.next_value()?;
6092 }
6093 }
6094 }
6095 Ok(CreateSchemaRequest {
6096 schema: schema__,
6097 })
6098 }
6099 }
6100 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
6101 }
6102}
6103impl serde::Serialize for CreateSchemaResponse {
6104 #[allow(deprecated)]
6105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6106 where
6107 S: serde::Serializer,
6108 {
6109 use serde::ser::SerializeStruct;
6110 let mut len = 0;
6111 if self.status.is_some() {
6112 len += 1;
6113 }
6114 if self.version.is_some() {
6115 len += 1;
6116 }
6117 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
6118 if let Some(v) = self.status.as_ref() {
6119 struct_ser.serialize_field("status", v)?;
6120 }
6121 if let Some(v) = self.version.as_ref() {
6122 struct_ser.serialize_field("version", v)?;
6123 }
6124 struct_ser.end()
6125 }
6126}
6127impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
6128 #[allow(deprecated)]
6129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6130 where
6131 D: serde::Deserializer<'de>,
6132 {
6133 const FIELDS: &[&str] = &[
6134 "status",
6135 "version",
6136 ];
6137
6138 #[allow(clippy::enum_variant_names)]
6139 enum GeneratedField {
6140 Status,
6141 Version,
6142 }
6143 impl<'de> serde::Deserialize<'de> for GeneratedField {
6144 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6145 where
6146 D: serde::Deserializer<'de>,
6147 {
6148 struct GeneratedVisitor;
6149
6150 impl serde::de::Visitor<'_> for GeneratedVisitor {
6151 type Value = GeneratedField;
6152
6153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6154 write!(formatter, "expected one of: {:?}", &FIELDS)
6155 }
6156
6157 #[allow(unused_variables)]
6158 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6159 where
6160 E: serde::de::Error,
6161 {
6162 match value {
6163 "status" => Ok(GeneratedField::Status),
6164 "version" => Ok(GeneratedField::Version),
6165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6166 }
6167 }
6168 }
6169 deserializer.deserialize_identifier(GeneratedVisitor)
6170 }
6171 }
6172 struct GeneratedVisitor;
6173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6174 type Value = CreateSchemaResponse;
6175
6176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6177 formatter.write_str("struct ddl_service.CreateSchemaResponse")
6178 }
6179
6180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
6181 where
6182 V: serde::de::MapAccess<'de>,
6183 {
6184 let mut status__ = None;
6185 let mut version__ = None;
6186 while let Some(k) = map_.next_key()? {
6187 match k {
6188 GeneratedField::Status => {
6189 if status__.is_some() {
6190 return Err(serde::de::Error::duplicate_field("status"));
6191 }
6192 status__ = map_.next_value()?;
6193 }
6194 GeneratedField::Version => {
6195 if version__.is_some() {
6196 return Err(serde::de::Error::duplicate_field("version"));
6197 }
6198 version__ = map_.next_value()?;
6199 }
6200 }
6201 }
6202 Ok(CreateSchemaResponse {
6203 status: status__,
6204 version: version__,
6205 })
6206 }
6207 }
6208 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
6209 }
6210}
6211impl serde::Serialize for CreateSecretRequest {
6212 #[allow(deprecated)]
6213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6214 where
6215 S: serde::Serializer,
6216 {
6217 use serde::ser::SerializeStruct;
6218 let mut len = 0;
6219 if !self.name.is_empty() {
6220 len += 1;
6221 }
6222 if !self.value.is_empty() {
6223 len += 1;
6224 }
6225 if self.database_id != 0 {
6226 len += 1;
6227 }
6228 if self.schema_id != 0 {
6229 len += 1;
6230 }
6231 if self.owner_id != 0 {
6232 len += 1;
6233 }
6234 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
6235 if !self.name.is_empty() {
6236 struct_ser.serialize_field("name", &self.name)?;
6237 }
6238 if !self.value.is_empty() {
6239 #[allow(clippy::needless_borrow)]
6240 #[allow(clippy::needless_borrows_for_generic_args)]
6241 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
6242 }
6243 if self.database_id != 0 {
6244 struct_ser.serialize_field("databaseId", &self.database_id)?;
6245 }
6246 if self.schema_id != 0 {
6247 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6248 }
6249 if self.owner_id != 0 {
6250 struct_ser.serialize_field("ownerId", &self.owner_id)?;
6251 }
6252 struct_ser.end()
6253 }
6254}
6255impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
6256 #[allow(deprecated)]
6257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6258 where
6259 D: serde::Deserializer<'de>,
6260 {
6261 const FIELDS: &[&str] = &[
6262 "name",
6263 "value",
6264 "database_id",
6265 "databaseId",
6266 "schema_id",
6267 "schemaId",
6268 "owner_id",
6269 "ownerId",
6270 ];
6271
6272 #[allow(clippy::enum_variant_names)]
6273 enum GeneratedField {
6274 Name,
6275 Value,
6276 DatabaseId,
6277 SchemaId,
6278 OwnerId,
6279 }
6280 impl<'de> serde::Deserialize<'de> for GeneratedField {
6281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6282 where
6283 D: serde::Deserializer<'de>,
6284 {
6285 struct GeneratedVisitor;
6286
6287 impl serde::de::Visitor<'_> for GeneratedVisitor {
6288 type Value = GeneratedField;
6289
6290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6291 write!(formatter, "expected one of: {:?}", &FIELDS)
6292 }
6293
6294 #[allow(unused_variables)]
6295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6296 where
6297 E: serde::de::Error,
6298 {
6299 match value {
6300 "name" => Ok(GeneratedField::Name),
6301 "value" => Ok(GeneratedField::Value),
6302 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6303 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6304 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
6305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6306 }
6307 }
6308 }
6309 deserializer.deserialize_identifier(GeneratedVisitor)
6310 }
6311 }
6312 struct GeneratedVisitor;
6313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6314 type Value = CreateSecretRequest;
6315
6316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6317 formatter.write_str("struct ddl_service.CreateSecretRequest")
6318 }
6319
6320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
6321 where
6322 V: serde::de::MapAccess<'de>,
6323 {
6324 let mut name__ = None;
6325 let mut value__ = None;
6326 let mut database_id__ = None;
6327 let mut schema_id__ = None;
6328 let mut owner_id__ = None;
6329 while let Some(k) = map_.next_key()? {
6330 match k {
6331 GeneratedField::Name => {
6332 if name__.is_some() {
6333 return Err(serde::de::Error::duplicate_field("name"));
6334 }
6335 name__ = Some(map_.next_value()?);
6336 }
6337 GeneratedField::Value => {
6338 if value__.is_some() {
6339 return Err(serde::de::Error::duplicate_field("value"));
6340 }
6341 value__ =
6342 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
6343 ;
6344 }
6345 GeneratedField::DatabaseId => {
6346 if database_id__.is_some() {
6347 return Err(serde::de::Error::duplicate_field("databaseId"));
6348 }
6349 database_id__ =
6350 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6351 ;
6352 }
6353 GeneratedField::SchemaId => {
6354 if schema_id__.is_some() {
6355 return Err(serde::de::Error::duplicate_field("schemaId"));
6356 }
6357 schema_id__ =
6358 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6359 ;
6360 }
6361 GeneratedField::OwnerId => {
6362 if owner_id__.is_some() {
6363 return Err(serde::de::Error::duplicate_field("ownerId"));
6364 }
6365 owner_id__ =
6366 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6367 ;
6368 }
6369 }
6370 }
6371 Ok(CreateSecretRequest {
6372 name: name__.unwrap_or_default(),
6373 value: value__.unwrap_or_default(),
6374 database_id: database_id__.unwrap_or_default(),
6375 schema_id: schema_id__.unwrap_or_default(),
6376 owner_id: owner_id__.unwrap_or_default(),
6377 })
6378 }
6379 }
6380 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
6381 }
6382}
6383impl serde::Serialize for CreateSecretResponse {
6384 #[allow(deprecated)]
6385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6386 where
6387 S: serde::Serializer,
6388 {
6389 use serde::ser::SerializeStruct;
6390 let mut len = 0;
6391 if self.version.is_some() {
6392 len += 1;
6393 }
6394 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
6395 if let Some(v) = self.version.as_ref() {
6396 struct_ser.serialize_field("version", v)?;
6397 }
6398 struct_ser.end()
6399 }
6400}
6401impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
6402 #[allow(deprecated)]
6403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6404 where
6405 D: serde::Deserializer<'de>,
6406 {
6407 const FIELDS: &[&str] = &[
6408 "version",
6409 ];
6410
6411 #[allow(clippy::enum_variant_names)]
6412 enum GeneratedField {
6413 Version,
6414 }
6415 impl<'de> serde::Deserialize<'de> for GeneratedField {
6416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6417 where
6418 D: serde::Deserializer<'de>,
6419 {
6420 struct GeneratedVisitor;
6421
6422 impl serde::de::Visitor<'_> for GeneratedVisitor {
6423 type Value = GeneratedField;
6424
6425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6426 write!(formatter, "expected one of: {:?}", &FIELDS)
6427 }
6428
6429 #[allow(unused_variables)]
6430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6431 where
6432 E: serde::de::Error,
6433 {
6434 match value {
6435 "version" => Ok(GeneratedField::Version),
6436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6437 }
6438 }
6439 }
6440 deserializer.deserialize_identifier(GeneratedVisitor)
6441 }
6442 }
6443 struct GeneratedVisitor;
6444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6445 type Value = CreateSecretResponse;
6446
6447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6448 formatter.write_str("struct ddl_service.CreateSecretResponse")
6449 }
6450
6451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
6452 where
6453 V: serde::de::MapAccess<'de>,
6454 {
6455 let mut version__ = None;
6456 while let Some(k) = map_.next_key()? {
6457 match k {
6458 GeneratedField::Version => {
6459 if version__.is_some() {
6460 return Err(serde::de::Error::duplicate_field("version"));
6461 }
6462 version__ = map_.next_value()?;
6463 }
6464 }
6465 }
6466 Ok(CreateSecretResponse {
6467 version: version__,
6468 })
6469 }
6470 }
6471 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
6472 }
6473}
6474impl serde::Serialize for CreateSinkRequest {
6475 #[allow(deprecated)]
6476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6477 where
6478 S: serde::Serializer,
6479 {
6480 use serde::ser::SerializeStruct;
6481 let mut len = 0;
6482 if self.sink.is_some() {
6483 len += 1;
6484 }
6485 if self.fragment_graph.is_some() {
6486 len += 1;
6487 }
6488 if !self.dependencies.is_empty() {
6489 len += 1;
6490 }
6491 if self.if_not_exists {
6492 len += 1;
6493 }
6494 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
6495 if let Some(v) = self.sink.as_ref() {
6496 struct_ser.serialize_field("sink", v)?;
6497 }
6498 if let Some(v) = self.fragment_graph.as_ref() {
6499 struct_ser.serialize_field("fragmentGraph", v)?;
6500 }
6501 if !self.dependencies.is_empty() {
6502 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6503 }
6504 if self.if_not_exists {
6505 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6506 }
6507 struct_ser.end()
6508 }
6509}
6510impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6511 #[allow(deprecated)]
6512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6513 where
6514 D: serde::Deserializer<'de>,
6515 {
6516 const FIELDS: &[&str] = &[
6517 "sink",
6518 "fragment_graph",
6519 "fragmentGraph",
6520 "dependencies",
6521 "if_not_exists",
6522 "ifNotExists",
6523 ];
6524
6525 #[allow(clippy::enum_variant_names)]
6526 enum GeneratedField {
6527 Sink,
6528 FragmentGraph,
6529 Dependencies,
6530 IfNotExists,
6531 }
6532 impl<'de> serde::Deserialize<'de> for GeneratedField {
6533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6534 where
6535 D: serde::Deserializer<'de>,
6536 {
6537 struct GeneratedVisitor;
6538
6539 impl serde::de::Visitor<'_> for GeneratedVisitor {
6540 type Value = GeneratedField;
6541
6542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6543 write!(formatter, "expected one of: {:?}", &FIELDS)
6544 }
6545
6546 #[allow(unused_variables)]
6547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6548 where
6549 E: serde::de::Error,
6550 {
6551 match value {
6552 "sink" => Ok(GeneratedField::Sink),
6553 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6554 "dependencies" => Ok(GeneratedField::Dependencies),
6555 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6556 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6557 }
6558 }
6559 }
6560 deserializer.deserialize_identifier(GeneratedVisitor)
6561 }
6562 }
6563 struct GeneratedVisitor;
6564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6565 type Value = CreateSinkRequest;
6566
6567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6568 formatter.write_str("struct ddl_service.CreateSinkRequest")
6569 }
6570
6571 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6572 where
6573 V: serde::de::MapAccess<'de>,
6574 {
6575 let mut sink__ = None;
6576 let mut fragment_graph__ = None;
6577 let mut dependencies__ = None;
6578 let mut if_not_exists__ = None;
6579 while let Some(k) = map_.next_key()? {
6580 match k {
6581 GeneratedField::Sink => {
6582 if sink__.is_some() {
6583 return Err(serde::de::Error::duplicate_field("sink"));
6584 }
6585 sink__ = map_.next_value()?;
6586 }
6587 GeneratedField::FragmentGraph => {
6588 if fragment_graph__.is_some() {
6589 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6590 }
6591 fragment_graph__ = map_.next_value()?;
6592 }
6593 GeneratedField::Dependencies => {
6594 if dependencies__.is_some() {
6595 return Err(serde::de::Error::duplicate_field("dependencies"));
6596 }
6597 dependencies__ =
6598 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6599 .into_iter().map(|x| x.0).collect())
6600 ;
6601 }
6602 GeneratedField::IfNotExists => {
6603 if if_not_exists__.is_some() {
6604 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6605 }
6606 if_not_exists__ = Some(map_.next_value()?);
6607 }
6608 }
6609 }
6610 Ok(CreateSinkRequest {
6611 sink: sink__,
6612 fragment_graph: fragment_graph__,
6613 dependencies: dependencies__.unwrap_or_default(),
6614 if_not_exists: if_not_exists__.unwrap_or_default(),
6615 })
6616 }
6617 }
6618 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6619 }
6620}
6621impl serde::Serialize for CreateSinkResponse {
6622 #[allow(deprecated)]
6623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6624 where
6625 S: serde::Serializer,
6626 {
6627 use serde::ser::SerializeStruct;
6628 let mut len = 0;
6629 if self.status.is_some() {
6630 len += 1;
6631 }
6632 if self.version.is_some() {
6633 len += 1;
6634 }
6635 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6636 if let Some(v) = self.status.as_ref() {
6637 struct_ser.serialize_field("status", v)?;
6638 }
6639 if let Some(v) = self.version.as_ref() {
6640 struct_ser.serialize_field("version", v)?;
6641 }
6642 struct_ser.end()
6643 }
6644}
6645impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6646 #[allow(deprecated)]
6647 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6648 where
6649 D: serde::Deserializer<'de>,
6650 {
6651 const FIELDS: &[&str] = &[
6652 "status",
6653 "version",
6654 ];
6655
6656 #[allow(clippy::enum_variant_names)]
6657 enum GeneratedField {
6658 Status,
6659 Version,
6660 }
6661 impl<'de> serde::Deserialize<'de> for GeneratedField {
6662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6663 where
6664 D: serde::Deserializer<'de>,
6665 {
6666 struct GeneratedVisitor;
6667
6668 impl serde::de::Visitor<'_> for GeneratedVisitor {
6669 type Value = GeneratedField;
6670
6671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6672 write!(formatter, "expected one of: {:?}", &FIELDS)
6673 }
6674
6675 #[allow(unused_variables)]
6676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6677 where
6678 E: serde::de::Error,
6679 {
6680 match value {
6681 "status" => Ok(GeneratedField::Status),
6682 "version" => Ok(GeneratedField::Version),
6683 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6684 }
6685 }
6686 }
6687 deserializer.deserialize_identifier(GeneratedVisitor)
6688 }
6689 }
6690 struct GeneratedVisitor;
6691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6692 type Value = CreateSinkResponse;
6693
6694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6695 formatter.write_str("struct ddl_service.CreateSinkResponse")
6696 }
6697
6698 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6699 where
6700 V: serde::de::MapAccess<'de>,
6701 {
6702 let mut status__ = None;
6703 let mut version__ = None;
6704 while let Some(k) = map_.next_key()? {
6705 match k {
6706 GeneratedField::Status => {
6707 if status__.is_some() {
6708 return Err(serde::de::Error::duplicate_field("status"));
6709 }
6710 status__ = map_.next_value()?;
6711 }
6712 GeneratedField::Version => {
6713 if version__.is_some() {
6714 return Err(serde::de::Error::duplicate_field("version"));
6715 }
6716 version__ = map_.next_value()?;
6717 }
6718 }
6719 }
6720 Ok(CreateSinkResponse {
6721 status: status__,
6722 version: version__,
6723 })
6724 }
6725 }
6726 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
6727 }
6728}
6729impl serde::Serialize for CreateSourceRequest {
6730 #[allow(deprecated)]
6731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6732 where
6733 S: serde::Serializer,
6734 {
6735 use serde::ser::SerializeStruct;
6736 let mut len = 0;
6737 if self.source.is_some() {
6738 len += 1;
6739 }
6740 if self.fragment_graph.is_some() {
6741 len += 1;
6742 }
6743 if self.if_not_exists {
6744 len += 1;
6745 }
6746 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
6747 if let Some(v) = self.source.as_ref() {
6748 struct_ser.serialize_field("source", v)?;
6749 }
6750 if let Some(v) = self.fragment_graph.as_ref() {
6751 struct_ser.serialize_field("fragmentGraph", v)?;
6752 }
6753 if self.if_not_exists {
6754 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6755 }
6756 struct_ser.end()
6757 }
6758}
6759impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
6760 #[allow(deprecated)]
6761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6762 where
6763 D: serde::Deserializer<'de>,
6764 {
6765 const FIELDS: &[&str] = &[
6766 "source",
6767 "fragment_graph",
6768 "fragmentGraph",
6769 "if_not_exists",
6770 "ifNotExists",
6771 ];
6772
6773 #[allow(clippy::enum_variant_names)]
6774 enum GeneratedField {
6775 Source,
6776 FragmentGraph,
6777 IfNotExists,
6778 }
6779 impl<'de> serde::Deserialize<'de> for GeneratedField {
6780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6781 where
6782 D: serde::Deserializer<'de>,
6783 {
6784 struct GeneratedVisitor;
6785
6786 impl serde::de::Visitor<'_> for GeneratedVisitor {
6787 type Value = GeneratedField;
6788
6789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6790 write!(formatter, "expected one of: {:?}", &FIELDS)
6791 }
6792
6793 #[allow(unused_variables)]
6794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6795 where
6796 E: serde::de::Error,
6797 {
6798 match value {
6799 "source" => Ok(GeneratedField::Source),
6800 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6801 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6803 }
6804 }
6805 }
6806 deserializer.deserialize_identifier(GeneratedVisitor)
6807 }
6808 }
6809 struct GeneratedVisitor;
6810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6811 type Value = CreateSourceRequest;
6812
6813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6814 formatter.write_str("struct ddl_service.CreateSourceRequest")
6815 }
6816
6817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
6818 where
6819 V: serde::de::MapAccess<'de>,
6820 {
6821 let mut source__ = None;
6822 let mut fragment_graph__ = None;
6823 let mut if_not_exists__ = None;
6824 while let Some(k) = map_.next_key()? {
6825 match k {
6826 GeneratedField::Source => {
6827 if source__.is_some() {
6828 return Err(serde::de::Error::duplicate_field("source"));
6829 }
6830 source__ = map_.next_value()?;
6831 }
6832 GeneratedField::FragmentGraph => {
6833 if fragment_graph__.is_some() {
6834 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6835 }
6836 fragment_graph__ = map_.next_value()?;
6837 }
6838 GeneratedField::IfNotExists => {
6839 if if_not_exists__.is_some() {
6840 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6841 }
6842 if_not_exists__ = Some(map_.next_value()?);
6843 }
6844 }
6845 }
6846 Ok(CreateSourceRequest {
6847 source: source__,
6848 fragment_graph: fragment_graph__,
6849 if_not_exists: if_not_exists__.unwrap_or_default(),
6850 })
6851 }
6852 }
6853 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
6854 }
6855}
6856impl serde::Serialize for CreateSourceResponse {
6857 #[allow(deprecated)]
6858 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6859 where
6860 S: serde::Serializer,
6861 {
6862 use serde::ser::SerializeStruct;
6863 let mut len = 0;
6864 if self.status.is_some() {
6865 len += 1;
6866 }
6867 if self.version.is_some() {
6868 len += 1;
6869 }
6870 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
6871 if let Some(v) = self.status.as_ref() {
6872 struct_ser.serialize_field("status", v)?;
6873 }
6874 if let Some(v) = self.version.as_ref() {
6875 struct_ser.serialize_field("version", v)?;
6876 }
6877 struct_ser.end()
6878 }
6879}
6880impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
6881 #[allow(deprecated)]
6882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6883 where
6884 D: serde::Deserializer<'de>,
6885 {
6886 const FIELDS: &[&str] = &[
6887 "status",
6888 "version",
6889 ];
6890
6891 #[allow(clippy::enum_variant_names)]
6892 enum GeneratedField {
6893 Status,
6894 Version,
6895 }
6896 impl<'de> serde::Deserialize<'de> for GeneratedField {
6897 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6898 where
6899 D: serde::Deserializer<'de>,
6900 {
6901 struct GeneratedVisitor;
6902
6903 impl serde::de::Visitor<'_> for GeneratedVisitor {
6904 type Value = GeneratedField;
6905
6906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6907 write!(formatter, "expected one of: {:?}", &FIELDS)
6908 }
6909
6910 #[allow(unused_variables)]
6911 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6912 where
6913 E: serde::de::Error,
6914 {
6915 match value {
6916 "status" => Ok(GeneratedField::Status),
6917 "version" => Ok(GeneratedField::Version),
6918 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6919 }
6920 }
6921 }
6922 deserializer.deserialize_identifier(GeneratedVisitor)
6923 }
6924 }
6925 struct GeneratedVisitor;
6926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6927 type Value = CreateSourceResponse;
6928
6929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6930 formatter.write_str("struct ddl_service.CreateSourceResponse")
6931 }
6932
6933 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
6934 where
6935 V: serde::de::MapAccess<'de>,
6936 {
6937 let mut status__ = None;
6938 let mut version__ = None;
6939 while let Some(k) = map_.next_key()? {
6940 match k {
6941 GeneratedField::Status => {
6942 if status__.is_some() {
6943 return Err(serde::de::Error::duplicate_field("status"));
6944 }
6945 status__ = map_.next_value()?;
6946 }
6947 GeneratedField::Version => {
6948 if version__.is_some() {
6949 return Err(serde::de::Error::duplicate_field("version"));
6950 }
6951 version__ = map_.next_value()?;
6952 }
6953 }
6954 }
6955 Ok(CreateSourceResponse {
6956 status: status__,
6957 version: version__,
6958 })
6959 }
6960 }
6961 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
6962 }
6963}
6964impl serde::Serialize for CreateSubscriptionRequest {
6965 #[allow(deprecated)]
6966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6967 where
6968 S: serde::Serializer,
6969 {
6970 use serde::ser::SerializeStruct;
6971 let mut len = 0;
6972 if self.subscription.is_some() {
6973 len += 1;
6974 }
6975 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
6976 if let Some(v) = self.subscription.as_ref() {
6977 struct_ser.serialize_field("subscription", v)?;
6978 }
6979 struct_ser.end()
6980 }
6981}
6982impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
6983 #[allow(deprecated)]
6984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6985 where
6986 D: serde::Deserializer<'de>,
6987 {
6988 const FIELDS: &[&str] = &[
6989 "subscription",
6990 ];
6991
6992 #[allow(clippy::enum_variant_names)]
6993 enum GeneratedField {
6994 Subscription,
6995 }
6996 impl<'de> serde::Deserialize<'de> for GeneratedField {
6997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6998 where
6999 D: serde::Deserializer<'de>,
7000 {
7001 struct GeneratedVisitor;
7002
7003 impl serde::de::Visitor<'_> for GeneratedVisitor {
7004 type Value = GeneratedField;
7005
7006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7007 write!(formatter, "expected one of: {:?}", &FIELDS)
7008 }
7009
7010 #[allow(unused_variables)]
7011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7012 where
7013 E: serde::de::Error,
7014 {
7015 match value {
7016 "subscription" => Ok(GeneratedField::Subscription),
7017 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7018 }
7019 }
7020 }
7021 deserializer.deserialize_identifier(GeneratedVisitor)
7022 }
7023 }
7024 struct GeneratedVisitor;
7025 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7026 type Value = CreateSubscriptionRequest;
7027
7028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7029 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
7030 }
7031
7032 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
7033 where
7034 V: serde::de::MapAccess<'de>,
7035 {
7036 let mut subscription__ = None;
7037 while let Some(k) = map_.next_key()? {
7038 match k {
7039 GeneratedField::Subscription => {
7040 if subscription__.is_some() {
7041 return Err(serde::de::Error::duplicate_field("subscription"));
7042 }
7043 subscription__ = map_.next_value()?;
7044 }
7045 }
7046 }
7047 Ok(CreateSubscriptionRequest {
7048 subscription: subscription__,
7049 })
7050 }
7051 }
7052 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
7053 }
7054}
7055impl serde::Serialize for CreateSubscriptionResponse {
7056 #[allow(deprecated)]
7057 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7058 where
7059 S: serde::Serializer,
7060 {
7061 use serde::ser::SerializeStruct;
7062 let mut len = 0;
7063 if self.status.is_some() {
7064 len += 1;
7065 }
7066 if self.version.is_some() {
7067 len += 1;
7068 }
7069 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
7070 if let Some(v) = self.status.as_ref() {
7071 struct_ser.serialize_field("status", v)?;
7072 }
7073 if let Some(v) = self.version.as_ref() {
7074 struct_ser.serialize_field("version", v)?;
7075 }
7076 struct_ser.end()
7077 }
7078}
7079impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
7080 #[allow(deprecated)]
7081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7082 where
7083 D: serde::Deserializer<'de>,
7084 {
7085 const FIELDS: &[&str] = &[
7086 "status",
7087 "version",
7088 ];
7089
7090 #[allow(clippy::enum_variant_names)]
7091 enum GeneratedField {
7092 Status,
7093 Version,
7094 }
7095 impl<'de> serde::Deserialize<'de> for GeneratedField {
7096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7097 where
7098 D: serde::Deserializer<'de>,
7099 {
7100 struct GeneratedVisitor;
7101
7102 impl serde::de::Visitor<'_> for GeneratedVisitor {
7103 type Value = GeneratedField;
7104
7105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7106 write!(formatter, "expected one of: {:?}", &FIELDS)
7107 }
7108
7109 #[allow(unused_variables)]
7110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7111 where
7112 E: serde::de::Error,
7113 {
7114 match value {
7115 "status" => Ok(GeneratedField::Status),
7116 "version" => Ok(GeneratedField::Version),
7117 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7118 }
7119 }
7120 }
7121 deserializer.deserialize_identifier(GeneratedVisitor)
7122 }
7123 }
7124 struct GeneratedVisitor;
7125 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7126 type Value = CreateSubscriptionResponse;
7127
7128 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7129 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
7130 }
7131
7132 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
7133 where
7134 V: serde::de::MapAccess<'de>,
7135 {
7136 let mut status__ = None;
7137 let mut version__ = None;
7138 while let Some(k) = map_.next_key()? {
7139 match k {
7140 GeneratedField::Status => {
7141 if status__.is_some() {
7142 return Err(serde::de::Error::duplicate_field("status"));
7143 }
7144 status__ = map_.next_value()?;
7145 }
7146 GeneratedField::Version => {
7147 if version__.is_some() {
7148 return Err(serde::de::Error::duplicate_field("version"));
7149 }
7150 version__ = map_.next_value()?;
7151 }
7152 }
7153 }
7154 Ok(CreateSubscriptionResponse {
7155 status: status__,
7156 version: version__,
7157 })
7158 }
7159 }
7160 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
7161 }
7162}
7163impl serde::Serialize for CreateTableRequest {
7164 #[allow(deprecated)]
7165 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7166 where
7167 S: serde::Serializer,
7168 {
7169 use serde::ser::SerializeStruct;
7170 let mut len = 0;
7171 if self.source.is_some() {
7172 len += 1;
7173 }
7174 if self.materialized_view.is_some() {
7175 len += 1;
7176 }
7177 if self.fragment_graph.is_some() {
7178 len += 1;
7179 }
7180 if self.job_type != 0 {
7181 len += 1;
7182 }
7183 if self.if_not_exists {
7184 len += 1;
7185 }
7186 if !self.dependencies.is_empty() {
7187 len += 1;
7188 }
7189 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
7190 if let Some(v) = self.source.as_ref() {
7191 struct_ser.serialize_field("source", v)?;
7192 }
7193 if let Some(v) = self.materialized_view.as_ref() {
7194 struct_ser.serialize_field("materializedView", v)?;
7195 }
7196 if let Some(v) = self.fragment_graph.as_ref() {
7197 struct_ser.serialize_field("fragmentGraph", v)?;
7198 }
7199 if self.job_type != 0 {
7200 let v = TableJobType::try_from(self.job_type)
7201 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
7202 struct_ser.serialize_field("jobType", &v)?;
7203 }
7204 if self.if_not_exists {
7205 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7206 }
7207 if !self.dependencies.is_empty() {
7208 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7209 }
7210 struct_ser.end()
7211 }
7212}
7213impl<'de> serde::Deserialize<'de> for CreateTableRequest {
7214 #[allow(deprecated)]
7215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7216 where
7217 D: serde::Deserializer<'de>,
7218 {
7219 const FIELDS: &[&str] = &[
7220 "source",
7221 "materialized_view",
7222 "materializedView",
7223 "fragment_graph",
7224 "fragmentGraph",
7225 "job_type",
7226 "jobType",
7227 "if_not_exists",
7228 "ifNotExists",
7229 "dependencies",
7230 ];
7231
7232 #[allow(clippy::enum_variant_names)]
7233 enum GeneratedField {
7234 Source,
7235 MaterializedView,
7236 FragmentGraph,
7237 JobType,
7238 IfNotExists,
7239 Dependencies,
7240 }
7241 impl<'de> serde::Deserialize<'de> for GeneratedField {
7242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7243 where
7244 D: serde::Deserializer<'de>,
7245 {
7246 struct GeneratedVisitor;
7247
7248 impl serde::de::Visitor<'_> for GeneratedVisitor {
7249 type Value = GeneratedField;
7250
7251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7252 write!(formatter, "expected one of: {:?}", &FIELDS)
7253 }
7254
7255 #[allow(unused_variables)]
7256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7257 where
7258 E: serde::de::Error,
7259 {
7260 match value {
7261 "source" => Ok(GeneratedField::Source),
7262 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
7263 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7264 "jobType" | "job_type" => Ok(GeneratedField::JobType),
7265 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7266 "dependencies" => Ok(GeneratedField::Dependencies),
7267 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7268 }
7269 }
7270 }
7271 deserializer.deserialize_identifier(GeneratedVisitor)
7272 }
7273 }
7274 struct GeneratedVisitor;
7275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7276 type Value = CreateTableRequest;
7277
7278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7279 formatter.write_str("struct ddl_service.CreateTableRequest")
7280 }
7281
7282 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
7283 where
7284 V: serde::de::MapAccess<'de>,
7285 {
7286 let mut source__ = None;
7287 let mut materialized_view__ = None;
7288 let mut fragment_graph__ = None;
7289 let mut job_type__ = None;
7290 let mut if_not_exists__ = None;
7291 let mut dependencies__ = None;
7292 while let Some(k) = map_.next_key()? {
7293 match k {
7294 GeneratedField::Source => {
7295 if source__.is_some() {
7296 return Err(serde::de::Error::duplicate_field("source"));
7297 }
7298 source__ = map_.next_value()?;
7299 }
7300 GeneratedField::MaterializedView => {
7301 if materialized_view__.is_some() {
7302 return Err(serde::de::Error::duplicate_field("materializedView"));
7303 }
7304 materialized_view__ = map_.next_value()?;
7305 }
7306 GeneratedField::FragmentGraph => {
7307 if fragment_graph__.is_some() {
7308 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7309 }
7310 fragment_graph__ = map_.next_value()?;
7311 }
7312 GeneratedField::JobType => {
7313 if job_type__.is_some() {
7314 return Err(serde::de::Error::duplicate_field("jobType"));
7315 }
7316 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
7317 }
7318 GeneratedField::IfNotExists => {
7319 if if_not_exists__.is_some() {
7320 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7321 }
7322 if_not_exists__ = Some(map_.next_value()?);
7323 }
7324 GeneratedField::Dependencies => {
7325 if dependencies__.is_some() {
7326 return Err(serde::de::Error::duplicate_field("dependencies"));
7327 }
7328 dependencies__ =
7329 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7330 .into_iter().map(|x| x.0).collect())
7331 ;
7332 }
7333 }
7334 }
7335 Ok(CreateTableRequest {
7336 source: source__,
7337 materialized_view: materialized_view__,
7338 fragment_graph: fragment_graph__,
7339 job_type: job_type__.unwrap_or_default(),
7340 if_not_exists: if_not_exists__.unwrap_or_default(),
7341 dependencies: dependencies__.unwrap_or_default(),
7342 })
7343 }
7344 }
7345 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
7346 }
7347}
7348impl serde::Serialize for CreateTableResponse {
7349 #[allow(deprecated)]
7350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7351 where
7352 S: serde::Serializer,
7353 {
7354 use serde::ser::SerializeStruct;
7355 let mut len = 0;
7356 if self.status.is_some() {
7357 len += 1;
7358 }
7359 if self.version.is_some() {
7360 len += 1;
7361 }
7362 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
7363 if let Some(v) = self.status.as_ref() {
7364 struct_ser.serialize_field("status", v)?;
7365 }
7366 if let Some(v) = self.version.as_ref() {
7367 struct_ser.serialize_field("version", v)?;
7368 }
7369 struct_ser.end()
7370 }
7371}
7372impl<'de> serde::Deserialize<'de> for CreateTableResponse {
7373 #[allow(deprecated)]
7374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7375 where
7376 D: serde::Deserializer<'de>,
7377 {
7378 const FIELDS: &[&str] = &[
7379 "status",
7380 "version",
7381 ];
7382
7383 #[allow(clippy::enum_variant_names)]
7384 enum GeneratedField {
7385 Status,
7386 Version,
7387 }
7388 impl<'de> serde::Deserialize<'de> for GeneratedField {
7389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7390 where
7391 D: serde::Deserializer<'de>,
7392 {
7393 struct GeneratedVisitor;
7394
7395 impl serde::de::Visitor<'_> for GeneratedVisitor {
7396 type Value = GeneratedField;
7397
7398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7399 write!(formatter, "expected one of: {:?}", &FIELDS)
7400 }
7401
7402 #[allow(unused_variables)]
7403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7404 where
7405 E: serde::de::Error,
7406 {
7407 match value {
7408 "status" => Ok(GeneratedField::Status),
7409 "version" => Ok(GeneratedField::Version),
7410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7411 }
7412 }
7413 }
7414 deserializer.deserialize_identifier(GeneratedVisitor)
7415 }
7416 }
7417 struct GeneratedVisitor;
7418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7419 type Value = CreateTableResponse;
7420
7421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7422 formatter.write_str("struct ddl_service.CreateTableResponse")
7423 }
7424
7425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
7426 where
7427 V: serde::de::MapAccess<'de>,
7428 {
7429 let mut status__ = None;
7430 let mut version__ = None;
7431 while let Some(k) = map_.next_key()? {
7432 match k {
7433 GeneratedField::Status => {
7434 if status__.is_some() {
7435 return Err(serde::de::Error::duplicate_field("status"));
7436 }
7437 status__ = map_.next_value()?;
7438 }
7439 GeneratedField::Version => {
7440 if version__.is_some() {
7441 return Err(serde::de::Error::duplicate_field("version"));
7442 }
7443 version__ = map_.next_value()?;
7444 }
7445 }
7446 }
7447 Ok(CreateTableResponse {
7448 status: status__,
7449 version: version__,
7450 })
7451 }
7452 }
7453 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
7454 }
7455}
7456impl serde::Serialize for CreateViewRequest {
7457 #[allow(deprecated)]
7458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7459 where
7460 S: serde::Serializer,
7461 {
7462 use serde::ser::SerializeStruct;
7463 let mut len = 0;
7464 if self.view.is_some() {
7465 len += 1;
7466 }
7467 if !self.dependencies.is_empty() {
7468 len += 1;
7469 }
7470 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
7471 if let Some(v) = self.view.as_ref() {
7472 struct_ser.serialize_field("view", v)?;
7473 }
7474 if !self.dependencies.is_empty() {
7475 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7476 }
7477 struct_ser.end()
7478 }
7479}
7480impl<'de> serde::Deserialize<'de> for CreateViewRequest {
7481 #[allow(deprecated)]
7482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7483 where
7484 D: serde::Deserializer<'de>,
7485 {
7486 const FIELDS: &[&str] = &[
7487 "view",
7488 "dependencies",
7489 ];
7490
7491 #[allow(clippy::enum_variant_names)]
7492 enum GeneratedField {
7493 View,
7494 Dependencies,
7495 }
7496 impl<'de> serde::Deserialize<'de> for GeneratedField {
7497 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7498 where
7499 D: serde::Deserializer<'de>,
7500 {
7501 struct GeneratedVisitor;
7502
7503 impl serde::de::Visitor<'_> for GeneratedVisitor {
7504 type Value = GeneratedField;
7505
7506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7507 write!(formatter, "expected one of: {:?}", &FIELDS)
7508 }
7509
7510 #[allow(unused_variables)]
7511 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7512 where
7513 E: serde::de::Error,
7514 {
7515 match value {
7516 "view" => Ok(GeneratedField::View),
7517 "dependencies" => Ok(GeneratedField::Dependencies),
7518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7519 }
7520 }
7521 }
7522 deserializer.deserialize_identifier(GeneratedVisitor)
7523 }
7524 }
7525 struct GeneratedVisitor;
7526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7527 type Value = CreateViewRequest;
7528
7529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7530 formatter.write_str("struct ddl_service.CreateViewRequest")
7531 }
7532
7533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7534 where
7535 V: serde::de::MapAccess<'de>,
7536 {
7537 let mut view__ = None;
7538 let mut dependencies__ = None;
7539 while let Some(k) = map_.next_key()? {
7540 match k {
7541 GeneratedField::View => {
7542 if view__.is_some() {
7543 return Err(serde::de::Error::duplicate_field("view"));
7544 }
7545 view__ = map_.next_value()?;
7546 }
7547 GeneratedField::Dependencies => {
7548 if dependencies__.is_some() {
7549 return Err(serde::de::Error::duplicate_field("dependencies"));
7550 }
7551 dependencies__ =
7552 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7553 .into_iter().map(|x| x.0).collect())
7554 ;
7555 }
7556 }
7557 }
7558 Ok(CreateViewRequest {
7559 view: view__,
7560 dependencies: dependencies__.unwrap_or_default(),
7561 })
7562 }
7563 }
7564 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7565 }
7566}
7567impl serde::Serialize for CreateViewResponse {
7568 #[allow(deprecated)]
7569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7570 where
7571 S: serde::Serializer,
7572 {
7573 use serde::ser::SerializeStruct;
7574 let mut len = 0;
7575 if self.status.is_some() {
7576 len += 1;
7577 }
7578 if self.version.is_some() {
7579 len += 1;
7580 }
7581 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7582 if let Some(v) = self.status.as_ref() {
7583 struct_ser.serialize_field("status", v)?;
7584 }
7585 if let Some(v) = self.version.as_ref() {
7586 struct_ser.serialize_field("version", v)?;
7587 }
7588 struct_ser.end()
7589 }
7590}
7591impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7592 #[allow(deprecated)]
7593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7594 where
7595 D: serde::Deserializer<'de>,
7596 {
7597 const FIELDS: &[&str] = &[
7598 "status",
7599 "version",
7600 ];
7601
7602 #[allow(clippy::enum_variant_names)]
7603 enum GeneratedField {
7604 Status,
7605 Version,
7606 }
7607 impl<'de> serde::Deserialize<'de> for GeneratedField {
7608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7609 where
7610 D: serde::Deserializer<'de>,
7611 {
7612 struct GeneratedVisitor;
7613
7614 impl serde::de::Visitor<'_> for GeneratedVisitor {
7615 type Value = GeneratedField;
7616
7617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7618 write!(formatter, "expected one of: {:?}", &FIELDS)
7619 }
7620
7621 #[allow(unused_variables)]
7622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7623 where
7624 E: serde::de::Error,
7625 {
7626 match value {
7627 "status" => Ok(GeneratedField::Status),
7628 "version" => Ok(GeneratedField::Version),
7629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7630 }
7631 }
7632 }
7633 deserializer.deserialize_identifier(GeneratedVisitor)
7634 }
7635 }
7636 struct GeneratedVisitor;
7637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7638 type Value = CreateViewResponse;
7639
7640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7641 formatter.write_str("struct ddl_service.CreateViewResponse")
7642 }
7643
7644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7645 where
7646 V: serde::de::MapAccess<'de>,
7647 {
7648 let mut status__ = None;
7649 let mut version__ = None;
7650 while let Some(k) = map_.next_key()? {
7651 match k {
7652 GeneratedField::Status => {
7653 if status__.is_some() {
7654 return Err(serde::de::Error::duplicate_field("status"));
7655 }
7656 status__ = map_.next_value()?;
7657 }
7658 GeneratedField::Version => {
7659 if version__.is_some() {
7660 return Err(serde::de::Error::duplicate_field("version"));
7661 }
7662 version__ = map_.next_value()?;
7663 }
7664 }
7665 }
7666 Ok(CreateViewResponse {
7667 status: status__,
7668 version: version__,
7669 })
7670 }
7671 }
7672 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7673 }
7674}
7675impl serde::Serialize for DdlProgress {
7676 #[allow(deprecated)]
7677 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7678 where
7679 S: serde::Serializer,
7680 {
7681 use serde::ser::SerializeStruct;
7682 let mut len = 0;
7683 if self.id != 0 {
7684 len += 1;
7685 }
7686 if !self.statement.is_empty() {
7687 len += 1;
7688 }
7689 if !self.progress.is_empty() {
7690 len += 1;
7691 }
7692 if !self.create_type.is_empty() {
7693 len += 1;
7694 }
7695 if self.initialized_at_time_millis != 0 {
7696 len += 1;
7697 }
7698 if self.is_serverless_backfill {
7699 len += 1;
7700 }
7701 if self.backfill_type != 0 {
7702 len += 1;
7703 }
7704 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
7705 if self.id != 0 {
7706 #[allow(clippy::needless_borrow)]
7707 #[allow(clippy::needless_borrows_for_generic_args)]
7708 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7709 }
7710 if !self.statement.is_empty() {
7711 struct_ser.serialize_field("statement", &self.statement)?;
7712 }
7713 if !self.progress.is_empty() {
7714 struct_ser.serialize_field("progress", &self.progress)?;
7715 }
7716 if !self.create_type.is_empty() {
7717 struct_ser.serialize_field("createType", &self.create_type)?;
7718 }
7719 if self.initialized_at_time_millis != 0 {
7720 #[allow(clippy::needless_borrow)]
7721 #[allow(clippy::needless_borrows_for_generic_args)]
7722 struct_ser.serialize_field("initializedAtTimeMillis", ToString::to_string(&self.initialized_at_time_millis).as_str())?;
7723 }
7724 if self.is_serverless_backfill {
7725 struct_ser.serialize_field("isServerlessBackfill", &self.is_serverless_backfill)?;
7726 }
7727 if self.backfill_type != 0 {
7728 let v = BackfillType::try_from(self.backfill_type)
7729 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill_type)))?;
7730 struct_ser.serialize_field("backfillType", &v)?;
7731 }
7732 struct_ser.end()
7733 }
7734}
7735impl<'de> serde::Deserialize<'de> for DdlProgress {
7736 #[allow(deprecated)]
7737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7738 where
7739 D: serde::Deserializer<'de>,
7740 {
7741 const FIELDS: &[&str] = &[
7742 "id",
7743 "statement",
7744 "progress",
7745 "create_type",
7746 "createType",
7747 "initialized_at_time_millis",
7748 "initializedAtTimeMillis",
7749 "is_serverless_backfill",
7750 "isServerlessBackfill",
7751 "backfill_type",
7752 "backfillType",
7753 ];
7754
7755 #[allow(clippy::enum_variant_names)]
7756 enum GeneratedField {
7757 Id,
7758 Statement,
7759 Progress,
7760 CreateType,
7761 InitializedAtTimeMillis,
7762 IsServerlessBackfill,
7763 BackfillType,
7764 }
7765 impl<'de> serde::Deserialize<'de> for GeneratedField {
7766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7767 where
7768 D: serde::Deserializer<'de>,
7769 {
7770 struct GeneratedVisitor;
7771
7772 impl serde::de::Visitor<'_> for GeneratedVisitor {
7773 type Value = GeneratedField;
7774
7775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7776 write!(formatter, "expected one of: {:?}", &FIELDS)
7777 }
7778
7779 #[allow(unused_variables)]
7780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7781 where
7782 E: serde::de::Error,
7783 {
7784 match value {
7785 "id" => Ok(GeneratedField::Id),
7786 "statement" => Ok(GeneratedField::Statement),
7787 "progress" => Ok(GeneratedField::Progress),
7788 "createType" | "create_type" => Ok(GeneratedField::CreateType),
7789 "initializedAtTimeMillis" | "initialized_at_time_millis" => Ok(GeneratedField::InitializedAtTimeMillis),
7790 "isServerlessBackfill" | "is_serverless_backfill" => Ok(GeneratedField::IsServerlessBackfill),
7791 "backfillType" | "backfill_type" => Ok(GeneratedField::BackfillType),
7792 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7793 }
7794 }
7795 }
7796 deserializer.deserialize_identifier(GeneratedVisitor)
7797 }
7798 }
7799 struct GeneratedVisitor;
7800 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7801 type Value = DdlProgress;
7802
7803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7804 formatter.write_str("struct ddl_service.DdlProgress")
7805 }
7806
7807 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
7808 where
7809 V: serde::de::MapAccess<'de>,
7810 {
7811 let mut id__ = None;
7812 let mut statement__ = None;
7813 let mut progress__ = None;
7814 let mut create_type__ = None;
7815 let mut initialized_at_time_millis__ = None;
7816 let mut is_serverless_backfill__ = None;
7817 let mut backfill_type__ = None;
7818 while let Some(k) = map_.next_key()? {
7819 match k {
7820 GeneratedField::Id => {
7821 if id__.is_some() {
7822 return Err(serde::de::Error::duplicate_field("id"));
7823 }
7824 id__ =
7825 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7826 ;
7827 }
7828 GeneratedField::Statement => {
7829 if statement__.is_some() {
7830 return Err(serde::de::Error::duplicate_field("statement"));
7831 }
7832 statement__ = Some(map_.next_value()?);
7833 }
7834 GeneratedField::Progress => {
7835 if progress__.is_some() {
7836 return Err(serde::de::Error::duplicate_field("progress"));
7837 }
7838 progress__ = Some(map_.next_value()?);
7839 }
7840 GeneratedField::CreateType => {
7841 if create_type__.is_some() {
7842 return Err(serde::de::Error::duplicate_field("createType"));
7843 }
7844 create_type__ = Some(map_.next_value()?);
7845 }
7846 GeneratedField::InitializedAtTimeMillis => {
7847 if initialized_at_time_millis__.is_some() {
7848 return Err(serde::de::Error::duplicate_field("initializedAtTimeMillis"));
7849 }
7850 initialized_at_time_millis__ =
7851 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7852 ;
7853 }
7854 GeneratedField::IsServerlessBackfill => {
7855 if is_serverless_backfill__.is_some() {
7856 return Err(serde::de::Error::duplicate_field("isServerlessBackfill"));
7857 }
7858 is_serverless_backfill__ = Some(map_.next_value()?);
7859 }
7860 GeneratedField::BackfillType => {
7861 if backfill_type__.is_some() {
7862 return Err(serde::de::Error::duplicate_field("backfillType"));
7863 }
7864 backfill_type__ = Some(map_.next_value::<BackfillType>()? as i32);
7865 }
7866 }
7867 }
7868 Ok(DdlProgress {
7869 id: id__.unwrap_or_default(),
7870 statement: statement__.unwrap_or_default(),
7871 progress: progress__.unwrap_or_default(),
7872 create_type: create_type__.unwrap_or_default(),
7873 initialized_at_time_millis: initialized_at_time_millis__.unwrap_or_default(),
7874 is_serverless_backfill: is_serverless_backfill__.unwrap_or_default(),
7875 backfill_type: backfill_type__.unwrap_or_default(),
7876 })
7877 }
7878 }
7879 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
7880 }
7881}
7882impl serde::Serialize for DropConnectionRequest {
7883 #[allow(deprecated)]
7884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7885 where
7886 S: serde::Serializer,
7887 {
7888 use serde::ser::SerializeStruct;
7889 let mut len = 0;
7890 if self.connection_id != 0 {
7891 len += 1;
7892 }
7893 if self.cascade {
7894 len += 1;
7895 }
7896 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
7897 if self.connection_id != 0 {
7898 struct_ser.serialize_field("connectionId", &self.connection_id)?;
7899 }
7900 if self.cascade {
7901 struct_ser.serialize_field("cascade", &self.cascade)?;
7902 }
7903 struct_ser.end()
7904 }
7905}
7906impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
7907 #[allow(deprecated)]
7908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7909 where
7910 D: serde::Deserializer<'de>,
7911 {
7912 const FIELDS: &[&str] = &[
7913 "connection_id",
7914 "connectionId",
7915 "cascade",
7916 ];
7917
7918 #[allow(clippy::enum_variant_names)]
7919 enum GeneratedField {
7920 ConnectionId,
7921 Cascade,
7922 }
7923 impl<'de> serde::Deserialize<'de> for GeneratedField {
7924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7925 where
7926 D: serde::Deserializer<'de>,
7927 {
7928 struct GeneratedVisitor;
7929
7930 impl serde::de::Visitor<'_> for GeneratedVisitor {
7931 type Value = GeneratedField;
7932
7933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7934 write!(formatter, "expected one of: {:?}", &FIELDS)
7935 }
7936
7937 #[allow(unused_variables)]
7938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7939 where
7940 E: serde::de::Error,
7941 {
7942 match value {
7943 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
7944 "cascade" => Ok(GeneratedField::Cascade),
7945 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7946 }
7947 }
7948 }
7949 deserializer.deserialize_identifier(GeneratedVisitor)
7950 }
7951 }
7952 struct GeneratedVisitor;
7953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7954 type Value = DropConnectionRequest;
7955
7956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7957 formatter.write_str("struct ddl_service.DropConnectionRequest")
7958 }
7959
7960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
7961 where
7962 V: serde::de::MapAccess<'de>,
7963 {
7964 let mut connection_id__ = None;
7965 let mut cascade__ = None;
7966 while let Some(k) = map_.next_key()? {
7967 match k {
7968 GeneratedField::ConnectionId => {
7969 if connection_id__.is_some() {
7970 return Err(serde::de::Error::duplicate_field("connectionId"));
7971 }
7972 connection_id__ =
7973 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7974 ;
7975 }
7976 GeneratedField::Cascade => {
7977 if cascade__.is_some() {
7978 return Err(serde::de::Error::duplicate_field("cascade"));
7979 }
7980 cascade__ = Some(map_.next_value()?);
7981 }
7982 }
7983 }
7984 Ok(DropConnectionRequest {
7985 connection_id: connection_id__.unwrap_or_default(),
7986 cascade: cascade__.unwrap_or_default(),
7987 })
7988 }
7989 }
7990 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
7991 }
7992}
7993impl serde::Serialize for DropConnectionResponse {
7994 #[allow(deprecated)]
7995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7996 where
7997 S: serde::Serializer,
7998 {
7999 use serde::ser::SerializeStruct;
8000 let mut len = 0;
8001 if self.status.is_some() {
8002 len += 1;
8003 }
8004 if self.version.is_some() {
8005 len += 1;
8006 }
8007 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
8008 if let Some(v) = self.status.as_ref() {
8009 struct_ser.serialize_field("status", v)?;
8010 }
8011 if let Some(v) = self.version.as_ref() {
8012 struct_ser.serialize_field("version", v)?;
8013 }
8014 struct_ser.end()
8015 }
8016}
8017impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
8018 #[allow(deprecated)]
8019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8020 where
8021 D: serde::Deserializer<'de>,
8022 {
8023 const FIELDS: &[&str] = &[
8024 "status",
8025 "version",
8026 ];
8027
8028 #[allow(clippy::enum_variant_names)]
8029 enum GeneratedField {
8030 Status,
8031 Version,
8032 }
8033 impl<'de> serde::Deserialize<'de> for GeneratedField {
8034 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8035 where
8036 D: serde::Deserializer<'de>,
8037 {
8038 struct GeneratedVisitor;
8039
8040 impl serde::de::Visitor<'_> for GeneratedVisitor {
8041 type Value = GeneratedField;
8042
8043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8044 write!(formatter, "expected one of: {:?}", &FIELDS)
8045 }
8046
8047 #[allow(unused_variables)]
8048 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8049 where
8050 E: serde::de::Error,
8051 {
8052 match value {
8053 "status" => Ok(GeneratedField::Status),
8054 "version" => Ok(GeneratedField::Version),
8055 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8056 }
8057 }
8058 }
8059 deserializer.deserialize_identifier(GeneratedVisitor)
8060 }
8061 }
8062 struct GeneratedVisitor;
8063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8064 type Value = DropConnectionResponse;
8065
8066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8067 formatter.write_str("struct ddl_service.DropConnectionResponse")
8068 }
8069
8070 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
8071 where
8072 V: serde::de::MapAccess<'de>,
8073 {
8074 let mut status__ = None;
8075 let mut version__ = None;
8076 while let Some(k) = map_.next_key()? {
8077 match k {
8078 GeneratedField::Status => {
8079 if status__.is_some() {
8080 return Err(serde::de::Error::duplicate_field("status"));
8081 }
8082 status__ = map_.next_value()?;
8083 }
8084 GeneratedField::Version => {
8085 if version__.is_some() {
8086 return Err(serde::de::Error::duplicate_field("version"));
8087 }
8088 version__ = map_.next_value()?;
8089 }
8090 }
8091 }
8092 Ok(DropConnectionResponse {
8093 status: status__,
8094 version: version__,
8095 })
8096 }
8097 }
8098 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
8099 }
8100}
8101impl serde::Serialize for DropDatabaseRequest {
8102 #[allow(deprecated)]
8103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8104 where
8105 S: serde::Serializer,
8106 {
8107 use serde::ser::SerializeStruct;
8108 let mut len = 0;
8109 if self.database_id != 0 {
8110 len += 1;
8111 }
8112 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
8113 if self.database_id != 0 {
8114 struct_ser.serialize_field("databaseId", &self.database_id)?;
8115 }
8116 struct_ser.end()
8117 }
8118}
8119impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
8120 #[allow(deprecated)]
8121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8122 where
8123 D: serde::Deserializer<'de>,
8124 {
8125 const FIELDS: &[&str] = &[
8126 "database_id",
8127 "databaseId",
8128 ];
8129
8130 #[allow(clippy::enum_variant_names)]
8131 enum GeneratedField {
8132 DatabaseId,
8133 }
8134 impl<'de> serde::Deserialize<'de> for GeneratedField {
8135 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8136 where
8137 D: serde::Deserializer<'de>,
8138 {
8139 struct GeneratedVisitor;
8140
8141 impl serde::de::Visitor<'_> for GeneratedVisitor {
8142 type Value = GeneratedField;
8143
8144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8145 write!(formatter, "expected one of: {:?}", &FIELDS)
8146 }
8147
8148 #[allow(unused_variables)]
8149 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8150 where
8151 E: serde::de::Error,
8152 {
8153 match value {
8154 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
8155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8156 }
8157 }
8158 }
8159 deserializer.deserialize_identifier(GeneratedVisitor)
8160 }
8161 }
8162 struct GeneratedVisitor;
8163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8164 type Value = DropDatabaseRequest;
8165
8166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8167 formatter.write_str("struct ddl_service.DropDatabaseRequest")
8168 }
8169
8170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
8171 where
8172 V: serde::de::MapAccess<'de>,
8173 {
8174 let mut database_id__ = None;
8175 while let Some(k) = map_.next_key()? {
8176 match k {
8177 GeneratedField::DatabaseId => {
8178 if database_id__.is_some() {
8179 return Err(serde::de::Error::duplicate_field("databaseId"));
8180 }
8181 database_id__ =
8182 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8183 ;
8184 }
8185 }
8186 }
8187 Ok(DropDatabaseRequest {
8188 database_id: database_id__.unwrap_or_default(),
8189 })
8190 }
8191 }
8192 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
8193 }
8194}
8195impl serde::Serialize for DropDatabaseResponse {
8196 #[allow(deprecated)]
8197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8198 where
8199 S: serde::Serializer,
8200 {
8201 use serde::ser::SerializeStruct;
8202 let mut len = 0;
8203 if self.status.is_some() {
8204 len += 1;
8205 }
8206 if self.version.is_some() {
8207 len += 1;
8208 }
8209 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
8210 if let Some(v) = self.status.as_ref() {
8211 struct_ser.serialize_field("status", v)?;
8212 }
8213 if let Some(v) = self.version.as_ref() {
8214 struct_ser.serialize_field("version", v)?;
8215 }
8216 struct_ser.end()
8217 }
8218}
8219impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
8220 #[allow(deprecated)]
8221 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8222 where
8223 D: serde::Deserializer<'de>,
8224 {
8225 const FIELDS: &[&str] = &[
8226 "status",
8227 "version",
8228 ];
8229
8230 #[allow(clippy::enum_variant_names)]
8231 enum GeneratedField {
8232 Status,
8233 Version,
8234 }
8235 impl<'de> serde::Deserialize<'de> for GeneratedField {
8236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8237 where
8238 D: serde::Deserializer<'de>,
8239 {
8240 struct GeneratedVisitor;
8241
8242 impl serde::de::Visitor<'_> for GeneratedVisitor {
8243 type Value = GeneratedField;
8244
8245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8246 write!(formatter, "expected one of: {:?}", &FIELDS)
8247 }
8248
8249 #[allow(unused_variables)]
8250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8251 where
8252 E: serde::de::Error,
8253 {
8254 match value {
8255 "status" => Ok(GeneratedField::Status),
8256 "version" => Ok(GeneratedField::Version),
8257 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8258 }
8259 }
8260 }
8261 deserializer.deserialize_identifier(GeneratedVisitor)
8262 }
8263 }
8264 struct GeneratedVisitor;
8265 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8266 type Value = DropDatabaseResponse;
8267
8268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8269 formatter.write_str("struct ddl_service.DropDatabaseResponse")
8270 }
8271
8272 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
8273 where
8274 V: serde::de::MapAccess<'de>,
8275 {
8276 let mut status__ = None;
8277 let mut version__ = None;
8278 while let Some(k) = map_.next_key()? {
8279 match k {
8280 GeneratedField::Status => {
8281 if status__.is_some() {
8282 return Err(serde::de::Error::duplicate_field("status"));
8283 }
8284 status__ = map_.next_value()?;
8285 }
8286 GeneratedField::Version => {
8287 if version__.is_some() {
8288 return Err(serde::de::Error::duplicate_field("version"));
8289 }
8290 version__ = map_.next_value()?;
8291 }
8292 }
8293 }
8294 Ok(DropDatabaseResponse {
8295 status: status__,
8296 version: version__,
8297 })
8298 }
8299 }
8300 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
8301 }
8302}
8303impl serde::Serialize for DropFunctionRequest {
8304 #[allow(deprecated)]
8305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8306 where
8307 S: serde::Serializer,
8308 {
8309 use serde::ser::SerializeStruct;
8310 let mut len = 0;
8311 if self.function_id != 0 {
8312 len += 1;
8313 }
8314 if self.cascade {
8315 len += 1;
8316 }
8317 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
8318 if self.function_id != 0 {
8319 struct_ser.serialize_field("functionId", &self.function_id)?;
8320 }
8321 if self.cascade {
8322 struct_ser.serialize_field("cascade", &self.cascade)?;
8323 }
8324 struct_ser.end()
8325 }
8326}
8327impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
8328 #[allow(deprecated)]
8329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8330 where
8331 D: serde::Deserializer<'de>,
8332 {
8333 const FIELDS: &[&str] = &[
8334 "function_id",
8335 "functionId",
8336 "cascade",
8337 ];
8338
8339 #[allow(clippy::enum_variant_names)]
8340 enum GeneratedField {
8341 FunctionId,
8342 Cascade,
8343 }
8344 impl<'de> serde::Deserialize<'de> for GeneratedField {
8345 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8346 where
8347 D: serde::Deserializer<'de>,
8348 {
8349 struct GeneratedVisitor;
8350
8351 impl serde::de::Visitor<'_> for GeneratedVisitor {
8352 type Value = GeneratedField;
8353
8354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8355 write!(formatter, "expected one of: {:?}", &FIELDS)
8356 }
8357
8358 #[allow(unused_variables)]
8359 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8360 where
8361 E: serde::de::Error,
8362 {
8363 match value {
8364 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
8365 "cascade" => Ok(GeneratedField::Cascade),
8366 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8367 }
8368 }
8369 }
8370 deserializer.deserialize_identifier(GeneratedVisitor)
8371 }
8372 }
8373 struct GeneratedVisitor;
8374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8375 type Value = DropFunctionRequest;
8376
8377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8378 formatter.write_str("struct ddl_service.DropFunctionRequest")
8379 }
8380
8381 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
8382 where
8383 V: serde::de::MapAccess<'de>,
8384 {
8385 let mut function_id__ = None;
8386 let mut cascade__ = None;
8387 while let Some(k) = map_.next_key()? {
8388 match k {
8389 GeneratedField::FunctionId => {
8390 if function_id__.is_some() {
8391 return Err(serde::de::Error::duplicate_field("functionId"));
8392 }
8393 function_id__ =
8394 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8395 ;
8396 }
8397 GeneratedField::Cascade => {
8398 if cascade__.is_some() {
8399 return Err(serde::de::Error::duplicate_field("cascade"));
8400 }
8401 cascade__ = Some(map_.next_value()?);
8402 }
8403 }
8404 }
8405 Ok(DropFunctionRequest {
8406 function_id: function_id__.unwrap_or_default(),
8407 cascade: cascade__.unwrap_or_default(),
8408 })
8409 }
8410 }
8411 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
8412 }
8413}
8414impl serde::Serialize for DropFunctionResponse {
8415 #[allow(deprecated)]
8416 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8417 where
8418 S: serde::Serializer,
8419 {
8420 use serde::ser::SerializeStruct;
8421 let mut len = 0;
8422 if self.status.is_some() {
8423 len += 1;
8424 }
8425 if self.version.is_some() {
8426 len += 1;
8427 }
8428 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
8429 if let Some(v) = self.status.as_ref() {
8430 struct_ser.serialize_field("status", v)?;
8431 }
8432 if let Some(v) = self.version.as_ref() {
8433 struct_ser.serialize_field("version", v)?;
8434 }
8435 struct_ser.end()
8436 }
8437}
8438impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
8439 #[allow(deprecated)]
8440 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8441 where
8442 D: serde::Deserializer<'de>,
8443 {
8444 const FIELDS: &[&str] = &[
8445 "status",
8446 "version",
8447 ];
8448
8449 #[allow(clippy::enum_variant_names)]
8450 enum GeneratedField {
8451 Status,
8452 Version,
8453 }
8454 impl<'de> serde::Deserialize<'de> for GeneratedField {
8455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8456 where
8457 D: serde::Deserializer<'de>,
8458 {
8459 struct GeneratedVisitor;
8460
8461 impl serde::de::Visitor<'_> for GeneratedVisitor {
8462 type Value = GeneratedField;
8463
8464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8465 write!(formatter, "expected one of: {:?}", &FIELDS)
8466 }
8467
8468 #[allow(unused_variables)]
8469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8470 where
8471 E: serde::de::Error,
8472 {
8473 match value {
8474 "status" => Ok(GeneratedField::Status),
8475 "version" => Ok(GeneratedField::Version),
8476 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8477 }
8478 }
8479 }
8480 deserializer.deserialize_identifier(GeneratedVisitor)
8481 }
8482 }
8483 struct GeneratedVisitor;
8484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8485 type Value = DropFunctionResponse;
8486
8487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8488 formatter.write_str("struct ddl_service.DropFunctionResponse")
8489 }
8490
8491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
8492 where
8493 V: serde::de::MapAccess<'de>,
8494 {
8495 let mut status__ = None;
8496 let mut version__ = None;
8497 while let Some(k) = map_.next_key()? {
8498 match k {
8499 GeneratedField::Status => {
8500 if status__.is_some() {
8501 return Err(serde::de::Error::duplicate_field("status"));
8502 }
8503 status__ = map_.next_value()?;
8504 }
8505 GeneratedField::Version => {
8506 if version__.is_some() {
8507 return Err(serde::de::Error::duplicate_field("version"));
8508 }
8509 version__ = map_.next_value()?;
8510 }
8511 }
8512 }
8513 Ok(DropFunctionResponse {
8514 status: status__,
8515 version: version__,
8516 })
8517 }
8518 }
8519 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
8520 }
8521}
8522impl serde::Serialize for DropIndexRequest {
8523 #[allow(deprecated)]
8524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8525 where
8526 S: serde::Serializer,
8527 {
8528 use serde::ser::SerializeStruct;
8529 let mut len = 0;
8530 if self.index_id != 0 {
8531 len += 1;
8532 }
8533 if self.cascade {
8534 len += 1;
8535 }
8536 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
8537 if self.index_id != 0 {
8538 struct_ser.serialize_field("indexId", &self.index_id)?;
8539 }
8540 if self.cascade {
8541 struct_ser.serialize_field("cascade", &self.cascade)?;
8542 }
8543 struct_ser.end()
8544 }
8545}
8546impl<'de> serde::Deserialize<'de> for DropIndexRequest {
8547 #[allow(deprecated)]
8548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8549 where
8550 D: serde::Deserializer<'de>,
8551 {
8552 const FIELDS: &[&str] = &[
8553 "index_id",
8554 "indexId",
8555 "cascade",
8556 ];
8557
8558 #[allow(clippy::enum_variant_names)]
8559 enum GeneratedField {
8560 IndexId,
8561 Cascade,
8562 }
8563 impl<'de> serde::Deserialize<'de> for GeneratedField {
8564 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8565 where
8566 D: serde::Deserializer<'de>,
8567 {
8568 struct GeneratedVisitor;
8569
8570 impl serde::de::Visitor<'_> for GeneratedVisitor {
8571 type Value = GeneratedField;
8572
8573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8574 write!(formatter, "expected one of: {:?}", &FIELDS)
8575 }
8576
8577 #[allow(unused_variables)]
8578 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8579 where
8580 E: serde::de::Error,
8581 {
8582 match value {
8583 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8584 "cascade" => Ok(GeneratedField::Cascade),
8585 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8586 }
8587 }
8588 }
8589 deserializer.deserialize_identifier(GeneratedVisitor)
8590 }
8591 }
8592 struct GeneratedVisitor;
8593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8594 type Value = DropIndexRequest;
8595
8596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8597 formatter.write_str("struct ddl_service.DropIndexRequest")
8598 }
8599
8600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8601 where
8602 V: serde::de::MapAccess<'de>,
8603 {
8604 let mut index_id__ = None;
8605 let mut cascade__ = None;
8606 while let Some(k) = map_.next_key()? {
8607 match k {
8608 GeneratedField::IndexId => {
8609 if index_id__.is_some() {
8610 return Err(serde::de::Error::duplicate_field("indexId"));
8611 }
8612 index_id__ =
8613 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8614 ;
8615 }
8616 GeneratedField::Cascade => {
8617 if cascade__.is_some() {
8618 return Err(serde::de::Error::duplicate_field("cascade"));
8619 }
8620 cascade__ = Some(map_.next_value()?);
8621 }
8622 }
8623 }
8624 Ok(DropIndexRequest {
8625 index_id: index_id__.unwrap_or_default(),
8626 cascade: cascade__.unwrap_or_default(),
8627 })
8628 }
8629 }
8630 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8631 }
8632}
8633impl serde::Serialize for DropIndexResponse {
8634 #[allow(deprecated)]
8635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8636 where
8637 S: serde::Serializer,
8638 {
8639 use serde::ser::SerializeStruct;
8640 let mut len = 0;
8641 if self.status.is_some() {
8642 len += 1;
8643 }
8644 if self.version.is_some() {
8645 len += 1;
8646 }
8647 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8648 if let Some(v) = self.status.as_ref() {
8649 struct_ser.serialize_field("status", v)?;
8650 }
8651 if let Some(v) = self.version.as_ref() {
8652 struct_ser.serialize_field("version", v)?;
8653 }
8654 struct_ser.end()
8655 }
8656}
8657impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8658 #[allow(deprecated)]
8659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8660 where
8661 D: serde::Deserializer<'de>,
8662 {
8663 const FIELDS: &[&str] = &[
8664 "status",
8665 "version",
8666 ];
8667
8668 #[allow(clippy::enum_variant_names)]
8669 enum GeneratedField {
8670 Status,
8671 Version,
8672 }
8673 impl<'de> serde::Deserialize<'de> for GeneratedField {
8674 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8675 where
8676 D: serde::Deserializer<'de>,
8677 {
8678 struct GeneratedVisitor;
8679
8680 impl serde::de::Visitor<'_> for GeneratedVisitor {
8681 type Value = GeneratedField;
8682
8683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8684 write!(formatter, "expected one of: {:?}", &FIELDS)
8685 }
8686
8687 #[allow(unused_variables)]
8688 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8689 where
8690 E: serde::de::Error,
8691 {
8692 match value {
8693 "status" => Ok(GeneratedField::Status),
8694 "version" => Ok(GeneratedField::Version),
8695 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8696 }
8697 }
8698 }
8699 deserializer.deserialize_identifier(GeneratedVisitor)
8700 }
8701 }
8702 struct GeneratedVisitor;
8703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8704 type Value = DropIndexResponse;
8705
8706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8707 formatter.write_str("struct ddl_service.DropIndexResponse")
8708 }
8709
8710 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
8711 where
8712 V: serde::de::MapAccess<'de>,
8713 {
8714 let mut status__ = None;
8715 let mut version__ = None;
8716 while let Some(k) = map_.next_key()? {
8717 match k {
8718 GeneratedField::Status => {
8719 if status__.is_some() {
8720 return Err(serde::de::Error::duplicate_field("status"));
8721 }
8722 status__ = map_.next_value()?;
8723 }
8724 GeneratedField::Version => {
8725 if version__.is_some() {
8726 return Err(serde::de::Error::duplicate_field("version"));
8727 }
8728 version__ = map_.next_value()?;
8729 }
8730 }
8731 }
8732 Ok(DropIndexResponse {
8733 status: status__,
8734 version: version__,
8735 })
8736 }
8737 }
8738 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
8739 }
8740}
8741impl serde::Serialize for DropMaterializedViewRequest {
8742 #[allow(deprecated)]
8743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8744 where
8745 S: serde::Serializer,
8746 {
8747 use serde::ser::SerializeStruct;
8748 let mut len = 0;
8749 if self.table_id != 0 {
8750 len += 1;
8751 }
8752 if self.cascade {
8753 len += 1;
8754 }
8755 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
8756 if self.table_id != 0 {
8757 struct_ser.serialize_field("tableId", &self.table_id)?;
8758 }
8759 if self.cascade {
8760 struct_ser.serialize_field("cascade", &self.cascade)?;
8761 }
8762 struct_ser.end()
8763 }
8764}
8765impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
8766 #[allow(deprecated)]
8767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8768 where
8769 D: serde::Deserializer<'de>,
8770 {
8771 const FIELDS: &[&str] = &[
8772 "table_id",
8773 "tableId",
8774 "cascade",
8775 ];
8776
8777 #[allow(clippy::enum_variant_names)]
8778 enum GeneratedField {
8779 TableId,
8780 Cascade,
8781 }
8782 impl<'de> serde::Deserialize<'de> for GeneratedField {
8783 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8784 where
8785 D: serde::Deserializer<'de>,
8786 {
8787 struct GeneratedVisitor;
8788
8789 impl serde::de::Visitor<'_> for GeneratedVisitor {
8790 type Value = GeneratedField;
8791
8792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8793 write!(formatter, "expected one of: {:?}", &FIELDS)
8794 }
8795
8796 #[allow(unused_variables)]
8797 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8798 where
8799 E: serde::de::Error,
8800 {
8801 match value {
8802 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8803 "cascade" => Ok(GeneratedField::Cascade),
8804 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8805 }
8806 }
8807 }
8808 deserializer.deserialize_identifier(GeneratedVisitor)
8809 }
8810 }
8811 struct GeneratedVisitor;
8812 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8813 type Value = DropMaterializedViewRequest;
8814
8815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8816 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
8817 }
8818
8819 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
8820 where
8821 V: serde::de::MapAccess<'de>,
8822 {
8823 let mut table_id__ = None;
8824 let mut cascade__ = None;
8825 while let Some(k) = map_.next_key()? {
8826 match k {
8827 GeneratedField::TableId => {
8828 if table_id__.is_some() {
8829 return Err(serde::de::Error::duplicate_field("tableId"));
8830 }
8831 table_id__ =
8832 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8833 ;
8834 }
8835 GeneratedField::Cascade => {
8836 if cascade__.is_some() {
8837 return Err(serde::de::Error::duplicate_field("cascade"));
8838 }
8839 cascade__ = Some(map_.next_value()?);
8840 }
8841 }
8842 }
8843 Ok(DropMaterializedViewRequest {
8844 table_id: table_id__.unwrap_or_default(),
8845 cascade: cascade__.unwrap_or_default(),
8846 })
8847 }
8848 }
8849 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
8850 }
8851}
8852impl serde::Serialize for DropMaterializedViewResponse {
8853 #[allow(deprecated)]
8854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8855 where
8856 S: serde::Serializer,
8857 {
8858 use serde::ser::SerializeStruct;
8859 let mut len = 0;
8860 if self.status.is_some() {
8861 len += 1;
8862 }
8863 if self.version.is_some() {
8864 len += 1;
8865 }
8866 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
8867 if let Some(v) = self.status.as_ref() {
8868 struct_ser.serialize_field("status", v)?;
8869 }
8870 if let Some(v) = self.version.as_ref() {
8871 struct_ser.serialize_field("version", v)?;
8872 }
8873 struct_ser.end()
8874 }
8875}
8876impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
8877 #[allow(deprecated)]
8878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8879 where
8880 D: serde::Deserializer<'de>,
8881 {
8882 const FIELDS: &[&str] = &[
8883 "status",
8884 "version",
8885 ];
8886
8887 #[allow(clippy::enum_variant_names)]
8888 enum GeneratedField {
8889 Status,
8890 Version,
8891 }
8892 impl<'de> serde::Deserialize<'de> for GeneratedField {
8893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8894 where
8895 D: serde::Deserializer<'de>,
8896 {
8897 struct GeneratedVisitor;
8898
8899 impl serde::de::Visitor<'_> for GeneratedVisitor {
8900 type Value = GeneratedField;
8901
8902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8903 write!(formatter, "expected one of: {:?}", &FIELDS)
8904 }
8905
8906 #[allow(unused_variables)]
8907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8908 where
8909 E: serde::de::Error,
8910 {
8911 match value {
8912 "status" => Ok(GeneratedField::Status),
8913 "version" => Ok(GeneratedField::Version),
8914 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8915 }
8916 }
8917 }
8918 deserializer.deserialize_identifier(GeneratedVisitor)
8919 }
8920 }
8921 struct GeneratedVisitor;
8922 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8923 type Value = DropMaterializedViewResponse;
8924
8925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8926 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
8927 }
8928
8929 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
8930 where
8931 V: serde::de::MapAccess<'de>,
8932 {
8933 let mut status__ = None;
8934 let mut version__ = None;
8935 while let Some(k) = map_.next_key()? {
8936 match k {
8937 GeneratedField::Status => {
8938 if status__.is_some() {
8939 return Err(serde::de::Error::duplicate_field("status"));
8940 }
8941 status__ = map_.next_value()?;
8942 }
8943 GeneratedField::Version => {
8944 if version__.is_some() {
8945 return Err(serde::de::Error::duplicate_field("version"));
8946 }
8947 version__ = map_.next_value()?;
8948 }
8949 }
8950 }
8951 Ok(DropMaterializedViewResponse {
8952 status: status__,
8953 version: version__,
8954 })
8955 }
8956 }
8957 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
8958 }
8959}
8960impl serde::Serialize for DropSchemaRequest {
8961 #[allow(deprecated)]
8962 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8963 where
8964 S: serde::Serializer,
8965 {
8966 use serde::ser::SerializeStruct;
8967 let mut len = 0;
8968 if self.schema_id != 0 {
8969 len += 1;
8970 }
8971 if self.cascade {
8972 len += 1;
8973 }
8974 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
8975 if self.schema_id != 0 {
8976 struct_ser.serialize_field("schemaId", &self.schema_id)?;
8977 }
8978 if self.cascade {
8979 struct_ser.serialize_field("cascade", &self.cascade)?;
8980 }
8981 struct_ser.end()
8982 }
8983}
8984impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
8985 #[allow(deprecated)]
8986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8987 where
8988 D: serde::Deserializer<'de>,
8989 {
8990 const FIELDS: &[&str] = &[
8991 "schema_id",
8992 "schemaId",
8993 "cascade",
8994 ];
8995
8996 #[allow(clippy::enum_variant_names)]
8997 enum GeneratedField {
8998 SchemaId,
8999 Cascade,
9000 }
9001 impl<'de> serde::Deserialize<'de> for GeneratedField {
9002 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9003 where
9004 D: serde::Deserializer<'de>,
9005 {
9006 struct GeneratedVisitor;
9007
9008 impl serde::de::Visitor<'_> for GeneratedVisitor {
9009 type Value = GeneratedField;
9010
9011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9012 write!(formatter, "expected one of: {:?}", &FIELDS)
9013 }
9014
9015 #[allow(unused_variables)]
9016 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9017 where
9018 E: serde::de::Error,
9019 {
9020 match value {
9021 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
9022 "cascade" => Ok(GeneratedField::Cascade),
9023 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9024 }
9025 }
9026 }
9027 deserializer.deserialize_identifier(GeneratedVisitor)
9028 }
9029 }
9030 struct GeneratedVisitor;
9031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9032 type Value = DropSchemaRequest;
9033
9034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9035 formatter.write_str("struct ddl_service.DropSchemaRequest")
9036 }
9037
9038 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
9039 where
9040 V: serde::de::MapAccess<'de>,
9041 {
9042 let mut schema_id__ = None;
9043 let mut cascade__ = None;
9044 while let Some(k) = map_.next_key()? {
9045 match k {
9046 GeneratedField::SchemaId => {
9047 if schema_id__.is_some() {
9048 return Err(serde::de::Error::duplicate_field("schemaId"));
9049 }
9050 schema_id__ =
9051 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9052 ;
9053 }
9054 GeneratedField::Cascade => {
9055 if cascade__.is_some() {
9056 return Err(serde::de::Error::duplicate_field("cascade"));
9057 }
9058 cascade__ = Some(map_.next_value()?);
9059 }
9060 }
9061 }
9062 Ok(DropSchemaRequest {
9063 schema_id: schema_id__.unwrap_or_default(),
9064 cascade: cascade__.unwrap_or_default(),
9065 })
9066 }
9067 }
9068 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
9069 }
9070}
9071impl serde::Serialize for DropSchemaResponse {
9072 #[allow(deprecated)]
9073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9074 where
9075 S: serde::Serializer,
9076 {
9077 use serde::ser::SerializeStruct;
9078 let mut len = 0;
9079 if self.status.is_some() {
9080 len += 1;
9081 }
9082 if self.version.is_some() {
9083 len += 1;
9084 }
9085 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
9086 if let Some(v) = self.status.as_ref() {
9087 struct_ser.serialize_field("status", v)?;
9088 }
9089 if let Some(v) = self.version.as_ref() {
9090 struct_ser.serialize_field("version", v)?;
9091 }
9092 struct_ser.end()
9093 }
9094}
9095impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
9096 #[allow(deprecated)]
9097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9098 where
9099 D: serde::Deserializer<'de>,
9100 {
9101 const FIELDS: &[&str] = &[
9102 "status",
9103 "version",
9104 ];
9105
9106 #[allow(clippy::enum_variant_names)]
9107 enum GeneratedField {
9108 Status,
9109 Version,
9110 }
9111 impl<'de> serde::Deserialize<'de> for GeneratedField {
9112 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9113 where
9114 D: serde::Deserializer<'de>,
9115 {
9116 struct GeneratedVisitor;
9117
9118 impl serde::de::Visitor<'_> for GeneratedVisitor {
9119 type Value = GeneratedField;
9120
9121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9122 write!(formatter, "expected one of: {:?}", &FIELDS)
9123 }
9124
9125 #[allow(unused_variables)]
9126 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9127 where
9128 E: serde::de::Error,
9129 {
9130 match value {
9131 "status" => Ok(GeneratedField::Status),
9132 "version" => Ok(GeneratedField::Version),
9133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9134 }
9135 }
9136 }
9137 deserializer.deserialize_identifier(GeneratedVisitor)
9138 }
9139 }
9140 struct GeneratedVisitor;
9141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9142 type Value = DropSchemaResponse;
9143
9144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9145 formatter.write_str("struct ddl_service.DropSchemaResponse")
9146 }
9147
9148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
9149 where
9150 V: serde::de::MapAccess<'de>,
9151 {
9152 let mut status__ = None;
9153 let mut version__ = None;
9154 while let Some(k) = map_.next_key()? {
9155 match k {
9156 GeneratedField::Status => {
9157 if status__.is_some() {
9158 return Err(serde::de::Error::duplicate_field("status"));
9159 }
9160 status__ = map_.next_value()?;
9161 }
9162 GeneratedField::Version => {
9163 if version__.is_some() {
9164 return Err(serde::de::Error::duplicate_field("version"));
9165 }
9166 version__ = map_.next_value()?;
9167 }
9168 }
9169 }
9170 Ok(DropSchemaResponse {
9171 status: status__,
9172 version: version__,
9173 })
9174 }
9175 }
9176 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
9177 }
9178}
9179impl serde::Serialize for DropSecretRequest {
9180 #[allow(deprecated)]
9181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9182 where
9183 S: serde::Serializer,
9184 {
9185 use serde::ser::SerializeStruct;
9186 let mut len = 0;
9187 if self.secret_id != 0 {
9188 len += 1;
9189 }
9190 if self.cascade {
9191 len += 1;
9192 }
9193 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
9194 if self.secret_id != 0 {
9195 struct_ser.serialize_field("secretId", &self.secret_id)?;
9196 }
9197 if self.cascade {
9198 struct_ser.serialize_field("cascade", &self.cascade)?;
9199 }
9200 struct_ser.end()
9201 }
9202}
9203impl<'de> serde::Deserialize<'de> for DropSecretRequest {
9204 #[allow(deprecated)]
9205 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9206 where
9207 D: serde::Deserializer<'de>,
9208 {
9209 const FIELDS: &[&str] = &[
9210 "secret_id",
9211 "secretId",
9212 "cascade",
9213 ];
9214
9215 #[allow(clippy::enum_variant_names)]
9216 enum GeneratedField {
9217 SecretId,
9218 Cascade,
9219 }
9220 impl<'de> serde::Deserialize<'de> for GeneratedField {
9221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9222 where
9223 D: serde::Deserializer<'de>,
9224 {
9225 struct GeneratedVisitor;
9226
9227 impl serde::de::Visitor<'_> for GeneratedVisitor {
9228 type Value = GeneratedField;
9229
9230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9231 write!(formatter, "expected one of: {:?}", &FIELDS)
9232 }
9233
9234 #[allow(unused_variables)]
9235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9236 where
9237 E: serde::de::Error,
9238 {
9239 match value {
9240 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
9241 "cascade" => Ok(GeneratedField::Cascade),
9242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9243 }
9244 }
9245 }
9246 deserializer.deserialize_identifier(GeneratedVisitor)
9247 }
9248 }
9249 struct GeneratedVisitor;
9250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9251 type Value = DropSecretRequest;
9252
9253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9254 formatter.write_str("struct ddl_service.DropSecretRequest")
9255 }
9256
9257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
9258 where
9259 V: serde::de::MapAccess<'de>,
9260 {
9261 let mut secret_id__ = None;
9262 let mut cascade__ = None;
9263 while let Some(k) = map_.next_key()? {
9264 match k {
9265 GeneratedField::SecretId => {
9266 if secret_id__.is_some() {
9267 return Err(serde::de::Error::duplicate_field("secretId"));
9268 }
9269 secret_id__ =
9270 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9271 ;
9272 }
9273 GeneratedField::Cascade => {
9274 if cascade__.is_some() {
9275 return Err(serde::de::Error::duplicate_field("cascade"));
9276 }
9277 cascade__ = Some(map_.next_value()?);
9278 }
9279 }
9280 }
9281 Ok(DropSecretRequest {
9282 secret_id: secret_id__.unwrap_or_default(),
9283 cascade: cascade__.unwrap_or_default(),
9284 })
9285 }
9286 }
9287 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
9288 }
9289}
9290impl serde::Serialize for DropSecretResponse {
9291 #[allow(deprecated)]
9292 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9293 where
9294 S: serde::Serializer,
9295 {
9296 use serde::ser::SerializeStruct;
9297 let mut len = 0;
9298 if self.version.is_some() {
9299 len += 1;
9300 }
9301 if self.status.is_some() {
9302 len += 1;
9303 }
9304 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
9305 if let Some(v) = self.version.as_ref() {
9306 struct_ser.serialize_field("version", v)?;
9307 }
9308 if let Some(v) = self.status.as_ref() {
9309 struct_ser.serialize_field("status", v)?;
9310 }
9311 struct_ser.end()
9312 }
9313}
9314impl<'de> serde::Deserialize<'de> for DropSecretResponse {
9315 #[allow(deprecated)]
9316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9317 where
9318 D: serde::Deserializer<'de>,
9319 {
9320 const FIELDS: &[&str] = &[
9321 "version",
9322 "status",
9323 ];
9324
9325 #[allow(clippy::enum_variant_names)]
9326 enum GeneratedField {
9327 Version,
9328 Status,
9329 }
9330 impl<'de> serde::Deserialize<'de> for GeneratedField {
9331 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9332 where
9333 D: serde::Deserializer<'de>,
9334 {
9335 struct GeneratedVisitor;
9336
9337 impl serde::de::Visitor<'_> for GeneratedVisitor {
9338 type Value = GeneratedField;
9339
9340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9341 write!(formatter, "expected one of: {:?}", &FIELDS)
9342 }
9343
9344 #[allow(unused_variables)]
9345 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9346 where
9347 E: serde::de::Error,
9348 {
9349 match value {
9350 "version" => Ok(GeneratedField::Version),
9351 "status" => Ok(GeneratedField::Status),
9352 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9353 }
9354 }
9355 }
9356 deserializer.deserialize_identifier(GeneratedVisitor)
9357 }
9358 }
9359 struct GeneratedVisitor;
9360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9361 type Value = DropSecretResponse;
9362
9363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9364 formatter.write_str("struct ddl_service.DropSecretResponse")
9365 }
9366
9367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
9368 where
9369 V: serde::de::MapAccess<'de>,
9370 {
9371 let mut version__ = None;
9372 let mut status__ = None;
9373 while let Some(k) = map_.next_key()? {
9374 match k {
9375 GeneratedField::Version => {
9376 if version__.is_some() {
9377 return Err(serde::de::Error::duplicate_field("version"));
9378 }
9379 version__ = map_.next_value()?;
9380 }
9381 GeneratedField::Status => {
9382 if status__.is_some() {
9383 return Err(serde::de::Error::duplicate_field("status"));
9384 }
9385 status__ = map_.next_value()?;
9386 }
9387 }
9388 }
9389 Ok(DropSecretResponse {
9390 version: version__,
9391 status: status__,
9392 })
9393 }
9394 }
9395 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
9396 }
9397}
9398impl serde::Serialize for DropSinkRequest {
9399 #[allow(deprecated)]
9400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9401 where
9402 S: serde::Serializer,
9403 {
9404 use serde::ser::SerializeStruct;
9405 let mut len = 0;
9406 if self.sink_id != 0 {
9407 len += 1;
9408 }
9409 if self.cascade {
9410 len += 1;
9411 }
9412 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
9413 if self.sink_id != 0 {
9414 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9415 }
9416 if self.cascade {
9417 struct_ser.serialize_field("cascade", &self.cascade)?;
9418 }
9419 struct_ser.end()
9420 }
9421}
9422impl<'de> serde::Deserialize<'de> for DropSinkRequest {
9423 #[allow(deprecated)]
9424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9425 where
9426 D: serde::Deserializer<'de>,
9427 {
9428 const FIELDS: &[&str] = &[
9429 "sink_id",
9430 "sinkId",
9431 "cascade",
9432 ];
9433
9434 #[allow(clippy::enum_variant_names)]
9435 enum GeneratedField {
9436 SinkId,
9437 Cascade,
9438 }
9439 impl<'de> serde::Deserialize<'de> for GeneratedField {
9440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9441 where
9442 D: serde::Deserializer<'de>,
9443 {
9444 struct GeneratedVisitor;
9445
9446 impl serde::de::Visitor<'_> for GeneratedVisitor {
9447 type Value = GeneratedField;
9448
9449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9450 write!(formatter, "expected one of: {:?}", &FIELDS)
9451 }
9452
9453 #[allow(unused_variables)]
9454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9455 where
9456 E: serde::de::Error,
9457 {
9458 match value {
9459 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9460 "cascade" => Ok(GeneratedField::Cascade),
9461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9462 }
9463 }
9464 }
9465 deserializer.deserialize_identifier(GeneratedVisitor)
9466 }
9467 }
9468 struct GeneratedVisitor;
9469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9470 type Value = DropSinkRequest;
9471
9472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9473 formatter.write_str("struct ddl_service.DropSinkRequest")
9474 }
9475
9476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
9477 where
9478 V: serde::de::MapAccess<'de>,
9479 {
9480 let mut sink_id__ = None;
9481 let mut cascade__ = None;
9482 while let Some(k) = map_.next_key()? {
9483 match k {
9484 GeneratedField::SinkId => {
9485 if sink_id__.is_some() {
9486 return Err(serde::de::Error::duplicate_field("sinkId"));
9487 }
9488 sink_id__ =
9489 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9490 ;
9491 }
9492 GeneratedField::Cascade => {
9493 if cascade__.is_some() {
9494 return Err(serde::de::Error::duplicate_field("cascade"));
9495 }
9496 cascade__ = Some(map_.next_value()?);
9497 }
9498 }
9499 }
9500 Ok(DropSinkRequest {
9501 sink_id: sink_id__.unwrap_or_default(),
9502 cascade: cascade__.unwrap_or_default(),
9503 })
9504 }
9505 }
9506 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
9507 }
9508}
9509impl serde::Serialize for DropSinkResponse {
9510 #[allow(deprecated)]
9511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9512 where
9513 S: serde::Serializer,
9514 {
9515 use serde::ser::SerializeStruct;
9516 let mut len = 0;
9517 if self.status.is_some() {
9518 len += 1;
9519 }
9520 if self.version.is_some() {
9521 len += 1;
9522 }
9523 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
9524 if let Some(v) = self.status.as_ref() {
9525 struct_ser.serialize_field("status", v)?;
9526 }
9527 if let Some(v) = self.version.as_ref() {
9528 struct_ser.serialize_field("version", v)?;
9529 }
9530 struct_ser.end()
9531 }
9532}
9533impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9534 #[allow(deprecated)]
9535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9536 where
9537 D: serde::Deserializer<'de>,
9538 {
9539 const FIELDS: &[&str] = &[
9540 "status",
9541 "version",
9542 ];
9543
9544 #[allow(clippy::enum_variant_names)]
9545 enum GeneratedField {
9546 Status,
9547 Version,
9548 }
9549 impl<'de> serde::Deserialize<'de> for GeneratedField {
9550 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9551 where
9552 D: serde::Deserializer<'de>,
9553 {
9554 struct GeneratedVisitor;
9555
9556 impl serde::de::Visitor<'_> for GeneratedVisitor {
9557 type Value = GeneratedField;
9558
9559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9560 write!(formatter, "expected one of: {:?}", &FIELDS)
9561 }
9562
9563 #[allow(unused_variables)]
9564 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9565 where
9566 E: serde::de::Error,
9567 {
9568 match value {
9569 "status" => Ok(GeneratedField::Status),
9570 "version" => Ok(GeneratedField::Version),
9571 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9572 }
9573 }
9574 }
9575 deserializer.deserialize_identifier(GeneratedVisitor)
9576 }
9577 }
9578 struct GeneratedVisitor;
9579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9580 type Value = DropSinkResponse;
9581
9582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9583 formatter.write_str("struct ddl_service.DropSinkResponse")
9584 }
9585
9586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9587 where
9588 V: serde::de::MapAccess<'de>,
9589 {
9590 let mut status__ = None;
9591 let mut version__ = None;
9592 while let Some(k) = map_.next_key()? {
9593 match k {
9594 GeneratedField::Status => {
9595 if status__.is_some() {
9596 return Err(serde::de::Error::duplicate_field("status"));
9597 }
9598 status__ = map_.next_value()?;
9599 }
9600 GeneratedField::Version => {
9601 if version__.is_some() {
9602 return Err(serde::de::Error::duplicate_field("version"));
9603 }
9604 version__ = map_.next_value()?;
9605 }
9606 }
9607 }
9608 Ok(DropSinkResponse {
9609 status: status__,
9610 version: version__,
9611 })
9612 }
9613 }
9614 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9615 }
9616}
9617impl serde::Serialize for DropSourceRequest {
9618 #[allow(deprecated)]
9619 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9620 where
9621 S: serde::Serializer,
9622 {
9623 use serde::ser::SerializeStruct;
9624 let mut len = 0;
9625 if self.source_id != 0 {
9626 len += 1;
9627 }
9628 if self.cascade {
9629 len += 1;
9630 }
9631 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9632 if self.source_id != 0 {
9633 struct_ser.serialize_field("sourceId", &self.source_id)?;
9634 }
9635 if self.cascade {
9636 struct_ser.serialize_field("cascade", &self.cascade)?;
9637 }
9638 struct_ser.end()
9639 }
9640}
9641impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9642 #[allow(deprecated)]
9643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9644 where
9645 D: serde::Deserializer<'de>,
9646 {
9647 const FIELDS: &[&str] = &[
9648 "source_id",
9649 "sourceId",
9650 "cascade",
9651 ];
9652
9653 #[allow(clippy::enum_variant_names)]
9654 enum GeneratedField {
9655 SourceId,
9656 Cascade,
9657 }
9658 impl<'de> serde::Deserialize<'de> for GeneratedField {
9659 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9660 where
9661 D: serde::Deserializer<'de>,
9662 {
9663 struct GeneratedVisitor;
9664
9665 impl serde::de::Visitor<'_> for GeneratedVisitor {
9666 type Value = GeneratedField;
9667
9668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9669 write!(formatter, "expected one of: {:?}", &FIELDS)
9670 }
9671
9672 #[allow(unused_variables)]
9673 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9674 where
9675 E: serde::de::Error,
9676 {
9677 match value {
9678 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9679 "cascade" => Ok(GeneratedField::Cascade),
9680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9681 }
9682 }
9683 }
9684 deserializer.deserialize_identifier(GeneratedVisitor)
9685 }
9686 }
9687 struct GeneratedVisitor;
9688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9689 type Value = DropSourceRequest;
9690
9691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9692 formatter.write_str("struct ddl_service.DropSourceRequest")
9693 }
9694
9695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9696 where
9697 V: serde::de::MapAccess<'de>,
9698 {
9699 let mut source_id__ = None;
9700 let mut cascade__ = None;
9701 while let Some(k) = map_.next_key()? {
9702 match k {
9703 GeneratedField::SourceId => {
9704 if source_id__.is_some() {
9705 return Err(serde::de::Error::duplicate_field("sourceId"));
9706 }
9707 source_id__ =
9708 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9709 ;
9710 }
9711 GeneratedField::Cascade => {
9712 if cascade__.is_some() {
9713 return Err(serde::de::Error::duplicate_field("cascade"));
9714 }
9715 cascade__ = Some(map_.next_value()?);
9716 }
9717 }
9718 }
9719 Ok(DropSourceRequest {
9720 source_id: source_id__.unwrap_or_default(),
9721 cascade: cascade__.unwrap_or_default(),
9722 })
9723 }
9724 }
9725 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
9726 }
9727}
9728impl serde::Serialize for DropSourceResponse {
9729 #[allow(deprecated)]
9730 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9731 where
9732 S: serde::Serializer,
9733 {
9734 use serde::ser::SerializeStruct;
9735 let mut len = 0;
9736 if self.status.is_some() {
9737 len += 1;
9738 }
9739 if self.version.is_some() {
9740 len += 1;
9741 }
9742 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
9743 if let Some(v) = self.status.as_ref() {
9744 struct_ser.serialize_field("status", v)?;
9745 }
9746 if let Some(v) = self.version.as_ref() {
9747 struct_ser.serialize_field("version", v)?;
9748 }
9749 struct_ser.end()
9750 }
9751}
9752impl<'de> serde::Deserialize<'de> for DropSourceResponse {
9753 #[allow(deprecated)]
9754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9755 where
9756 D: serde::Deserializer<'de>,
9757 {
9758 const FIELDS: &[&str] = &[
9759 "status",
9760 "version",
9761 ];
9762
9763 #[allow(clippy::enum_variant_names)]
9764 enum GeneratedField {
9765 Status,
9766 Version,
9767 }
9768 impl<'de> serde::Deserialize<'de> for GeneratedField {
9769 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9770 where
9771 D: serde::Deserializer<'de>,
9772 {
9773 struct GeneratedVisitor;
9774
9775 impl serde::de::Visitor<'_> for GeneratedVisitor {
9776 type Value = GeneratedField;
9777
9778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9779 write!(formatter, "expected one of: {:?}", &FIELDS)
9780 }
9781
9782 #[allow(unused_variables)]
9783 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9784 where
9785 E: serde::de::Error,
9786 {
9787 match value {
9788 "status" => Ok(GeneratedField::Status),
9789 "version" => Ok(GeneratedField::Version),
9790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9791 }
9792 }
9793 }
9794 deserializer.deserialize_identifier(GeneratedVisitor)
9795 }
9796 }
9797 struct GeneratedVisitor;
9798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9799 type Value = DropSourceResponse;
9800
9801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9802 formatter.write_str("struct ddl_service.DropSourceResponse")
9803 }
9804
9805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9806 where
9807 V: serde::de::MapAccess<'de>,
9808 {
9809 let mut status__ = None;
9810 let mut version__ = None;
9811 while let Some(k) = map_.next_key()? {
9812 match k {
9813 GeneratedField::Status => {
9814 if status__.is_some() {
9815 return Err(serde::de::Error::duplicate_field("status"));
9816 }
9817 status__ = map_.next_value()?;
9818 }
9819 GeneratedField::Version => {
9820 if version__.is_some() {
9821 return Err(serde::de::Error::duplicate_field("version"));
9822 }
9823 version__ = map_.next_value()?;
9824 }
9825 }
9826 }
9827 Ok(DropSourceResponse {
9828 status: status__,
9829 version: version__,
9830 })
9831 }
9832 }
9833 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9834 }
9835}
9836impl serde::Serialize for DropSubscriptionRequest {
9837 #[allow(deprecated)]
9838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9839 where
9840 S: serde::Serializer,
9841 {
9842 use serde::ser::SerializeStruct;
9843 let mut len = 0;
9844 if self.subscription_id != 0 {
9845 len += 1;
9846 }
9847 if self.cascade {
9848 len += 1;
9849 }
9850 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9851 if self.subscription_id != 0 {
9852 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9853 }
9854 if self.cascade {
9855 struct_ser.serialize_field("cascade", &self.cascade)?;
9856 }
9857 struct_ser.end()
9858 }
9859}
9860impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9861 #[allow(deprecated)]
9862 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9863 where
9864 D: serde::Deserializer<'de>,
9865 {
9866 const FIELDS: &[&str] = &[
9867 "subscription_id",
9868 "subscriptionId",
9869 "cascade",
9870 ];
9871
9872 #[allow(clippy::enum_variant_names)]
9873 enum GeneratedField {
9874 SubscriptionId,
9875 Cascade,
9876 }
9877 impl<'de> serde::Deserialize<'de> for GeneratedField {
9878 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9879 where
9880 D: serde::Deserializer<'de>,
9881 {
9882 struct GeneratedVisitor;
9883
9884 impl serde::de::Visitor<'_> for GeneratedVisitor {
9885 type Value = GeneratedField;
9886
9887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9888 write!(formatter, "expected one of: {:?}", &FIELDS)
9889 }
9890
9891 #[allow(unused_variables)]
9892 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9893 where
9894 E: serde::de::Error,
9895 {
9896 match value {
9897 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9898 "cascade" => Ok(GeneratedField::Cascade),
9899 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9900 }
9901 }
9902 }
9903 deserializer.deserialize_identifier(GeneratedVisitor)
9904 }
9905 }
9906 struct GeneratedVisitor;
9907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9908 type Value = DropSubscriptionRequest;
9909
9910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9911 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9912 }
9913
9914 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9915 where
9916 V: serde::de::MapAccess<'de>,
9917 {
9918 let mut subscription_id__ = None;
9919 let mut cascade__ = None;
9920 while let Some(k) = map_.next_key()? {
9921 match k {
9922 GeneratedField::SubscriptionId => {
9923 if subscription_id__.is_some() {
9924 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9925 }
9926 subscription_id__ =
9927 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9928 ;
9929 }
9930 GeneratedField::Cascade => {
9931 if cascade__.is_some() {
9932 return Err(serde::de::Error::duplicate_field("cascade"));
9933 }
9934 cascade__ = Some(map_.next_value()?);
9935 }
9936 }
9937 }
9938 Ok(DropSubscriptionRequest {
9939 subscription_id: subscription_id__.unwrap_or_default(),
9940 cascade: cascade__.unwrap_or_default(),
9941 })
9942 }
9943 }
9944 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9945 }
9946}
9947impl serde::Serialize for DropSubscriptionResponse {
9948 #[allow(deprecated)]
9949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9950 where
9951 S: serde::Serializer,
9952 {
9953 use serde::ser::SerializeStruct;
9954 let mut len = 0;
9955 if self.status.is_some() {
9956 len += 1;
9957 }
9958 if self.version.is_some() {
9959 len += 1;
9960 }
9961 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9962 if let Some(v) = self.status.as_ref() {
9963 struct_ser.serialize_field("status", v)?;
9964 }
9965 if let Some(v) = self.version.as_ref() {
9966 struct_ser.serialize_field("version", v)?;
9967 }
9968 struct_ser.end()
9969 }
9970}
9971impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9972 #[allow(deprecated)]
9973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9974 where
9975 D: serde::Deserializer<'de>,
9976 {
9977 const FIELDS: &[&str] = &[
9978 "status",
9979 "version",
9980 ];
9981
9982 #[allow(clippy::enum_variant_names)]
9983 enum GeneratedField {
9984 Status,
9985 Version,
9986 }
9987 impl<'de> serde::Deserialize<'de> for GeneratedField {
9988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9989 where
9990 D: serde::Deserializer<'de>,
9991 {
9992 struct GeneratedVisitor;
9993
9994 impl serde::de::Visitor<'_> for GeneratedVisitor {
9995 type Value = GeneratedField;
9996
9997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9998 write!(formatter, "expected one of: {:?}", &FIELDS)
9999 }
10000
10001 #[allow(unused_variables)]
10002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10003 where
10004 E: serde::de::Error,
10005 {
10006 match value {
10007 "status" => Ok(GeneratedField::Status),
10008 "version" => Ok(GeneratedField::Version),
10009 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10010 }
10011 }
10012 }
10013 deserializer.deserialize_identifier(GeneratedVisitor)
10014 }
10015 }
10016 struct GeneratedVisitor;
10017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10018 type Value = DropSubscriptionResponse;
10019
10020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10021 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
10022 }
10023
10024 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
10025 where
10026 V: serde::de::MapAccess<'de>,
10027 {
10028 let mut status__ = None;
10029 let mut version__ = None;
10030 while let Some(k) = map_.next_key()? {
10031 match k {
10032 GeneratedField::Status => {
10033 if status__.is_some() {
10034 return Err(serde::de::Error::duplicate_field("status"));
10035 }
10036 status__ = map_.next_value()?;
10037 }
10038 GeneratedField::Version => {
10039 if version__.is_some() {
10040 return Err(serde::de::Error::duplicate_field("version"));
10041 }
10042 version__ = map_.next_value()?;
10043 }
10044 }
10045 }
10046 Ok(DropSubscriptionResponse {
10047 status: status__,
10048 version: version__,
10049 })
10050 }
10051 }
10052 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
10053 }
10054}
10055impl serde::Serialize for DropTableRequest {
10056 #[allow(deprecated)]
10057 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10058 where
10059 S: serde::Serializer,
10060 {
10061 use serde::ser::SerializeStruct;
10062 let mut len = 0;
10063 if self.table_id != 0 {
10064 len += 1;
10065 }
10066 if self.cascade {
10067 len += 1;
10068 }
10069 if self.source_id.is_some() {
10070 len += 1;
10071 }
10072 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
10073 if self.table_id != 0 {
10074 struct_ser.serialize_field("tableId", &self.table_id)?;
10075 }
10076 if self.cascade {
10077 struct_ser.serialize_field("cascade", &self.cascade)?;
10078 }
10079 if let Some(v) = self.source_id.as_ref() {
10080 match v {
10081 drop_table_request::SourceId::Id(v) => {
10082 struct_ser.serialize_field("id", v)?;
10083 }
10084 }
10085 }
10086 struct_ser.end()
10087 }
10088}
10089impl<'de> serde::Deserialize<'de> for DropTableRequest {
10090 #[allow(deprecated)]
10091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10092 where
10093 D: serde::Deserializer<'de>,
10094 {
10095 const FIELDS: &[&str] = &[
10096 "table_id",
10097 "tableId",
10098 "cascade",
10099 "id",
10100 ];
10101
10102 #[allow(clippy::enum_variant_names)]
10103 enum GeneratedField {
10104 TableId,
10105 Cascade,
10106 Id,
10107 }
10108 impl<'de> serde::Deserialize<'de> for GeneratedField {
10109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10110 where
10111 D: serde::Deserializer<'de>,
10112 {
10113 struct GeneratedVisitor;
10114
10115 impl serde::de::Visitor<'_> for GeneratedVisitor {
10116 type Value = GeneratedField;
10117
10118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10119 write!(formatter, "expected one of: {:?}", &FIELDS)
10120 }
10121
10122 #[allow(unused_variables)]
10123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10124 where
10125 E: serde::de::Error,
10126 {
10127 match value {
10128 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10129 "cascade" => Ok(GeneratedField::Cascade),
10130 "id" => Ok(GeneratedField::Id),
10131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10132 }
10133 }
10134 }
10135 deserializer.deserialize_identifier(GeneratedVisitor)
10136 }
10137 }
10138 struct GeneratedVisitor;
10139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10140 type Value = DropTableRequest;
10141
10142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10143 formatter.write_str("struct ddl_service.DropTableRequest")
10144 }
10145
10146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
10147 where
10148 V: serde::de::MapAccess<'de>,
10149 {
10150 let mut table_id__ = None;
10151 let mut cascade__ = None;
10152 let mut source_id__ = None;
10153 while let Some(k) = map_.next_key()? {
10154 match k {
10155 GeneratedField::TableId => {
10156 if table_id__.is_some() {
10157 return Err(serde::de::Error::duplicate_field("tableId"));
10158 }
10159 table_id__ =
10160 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10161 ;
10162 }
10163 GeneratedField::Cascade => {
10164 if cascade__.is_some() {
10165 return Err(serde::de::Error::duplicate_field("cascade"));
10166 }
10167 cascade__ = Some(map_.next_value()?);
10168 }
10169 GeneratedField::Id => {
10170 if source_id__.is_some() {
10171 return Err(serde::de::Error::duplicate_field("id"));
10172 }
10173 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
10174 }
10175 }
10176 }
10177 Ok(DropTableRequest {
10178 table_id: table_id__.unwrap_or_default(),
10179 cascade: cascade__.unwrap_or_default(),
10180 source_id: source_id__,
10181 })
10182 }
10183 }
10184 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
10185 }
10186}
10187impl serde::Serialize for DropTableResponse {
10188 #[allow(deprecated)]
10189 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10190 where
10191 S: serde::Serializer,
10192 {
10193 use serde::ser::SerializeStruct;
10194 let mut len = 0;
10195 if self.status.is_some() {
10196 len += 1;
10197 }
10198 if self.version.is_some() {
10199 len += 1;
10200 }
10201 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
10202 if let Some(v) = self.status.as_ref() {
10203 struct_ser.serialize_field("status", v)?;
10204 }
10205 if let Some(v) = self.version.as_ref() {
10206 struct_ser.serialize_field("version", v)?;
10207 }
10208 struct_ser.end()
10209 }
10210}
10211impl<'de> serde::Deserialize<'de> for DropTableResponse {
10212 #[allow(deprecated)]
10213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10214 where
10215 D: serde::Deserializer<'de>,
10216 {
10217 const FIELDS: &[&str] = &[
10218 "status",
10219 "version",
10220 ];
10221
10222 #[allow(clippy::enum_variant_names)]
10223 enum GeneratedField {
10224 Status,
10225 Version,
10226 }
10227 impl<'de> serde::Deserialize<'de> for GeneratedField {
10228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10229 where
10230 D: serde::Deserializer<'de>,
10231 {
10232 struct GeneratedVisitor;
10233
10234 impl serde::de::Visitor<'_> for GeneratedVisitor {
10235 type Value = GeneratedField;
10236
10237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10238 write!(formatter, "expected one of: {:?}", &FIELDS)
10239 }
10240
10241 #[allow(unused_variables)]
10242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10243 where
10244 E: serde::de::Error,
10245 {
10246 match value {
10247 "status" => Ok(GeneratedField::Status),
10248 "version" => Ok(GeneratedField::Version),
10249 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10250 }
10251 }
10252 }
10253 deserializer.deserialize_identifier(GeneratedVisitor)
10254 }
10255 }
10256 struct GeneratedVisitor;
10257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10258 type Value = DropTableResponse;
10259
10260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10261 formatter.write_str("struct ddl_service.DropTableResponse")
10262 }
10263
10264 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
10265 where
10266 V: serde::de::MapAccess<'de>,
10267 {
10268 let mut status__ = None;
10269 let mut version__ = None;
10270 while let Some(k) = map_.next_key()? {
10271 match k {
10272 GeneratedField::Status => {
10273 if status__.is_some() {
10274 return Err(serde::de::Error::duplicate_field("status"));
10275 }
10276 status__ = map_.next_value()?;
10277 }
10278 GeneratedField::Version => {
10279 if version__.is_some() {
10280 return Err(serde::de::Error::duplicate_field("version"));
10281 }
10282 version__ = map_.next_value()?;
10283 }
10284 }
10285 }
10286 Ok(DropTableResponse {
10287 status: status__,
10288 version: version__,
10289 })
10290 }
10291 }
10292 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
10293 }
10294}
10295impl serde::Serialize for DropViewRequest {
10296 #[allow(deprecated)]
10297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10298 where
10299 S: serde::Serializer,
10300 {
10301 use serde::ser::SerializeStruct;
10302 let mut len = 0;
10303 if self.view_id != 0 {
10304 len += 1;
10305 }
10306 if self.cascade {
10307 len += 1;
10308 }
10309 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
10310 if self.view_id != 0 {
10311 struct_ser.serialize_field("viewId", &self.view_id)?;
10312 }
10313 if self.cascade {
10314 struct_ser.serialize_field("cascade", &self.cascade)?;
10315 }
10316 struct_ser.end()
10317 }
10318}
10319impl<'de> serde::Deserialize<'de> for DropViewRequest {
10320 #[allow(deprecated)]
10321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10322 where
10323 D: serde::Deserializer<'de>,
10324 {
10325 const FIELDS: &[&str] = &[
10326 "view_id",
10327 "viewId",
10328 "cascade",
10329 ];
10330
10331 #[allow(clippy::enum_variant_names)]
10332 enum GeneratedField {
10333 ViewId,
10334 Cascade,
10335 }
10336 impl<'de> serde::Deserialize<'de> for GeneratedField {
10337 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10338 where
10339 D: serde::Deserializer<'de>,
10340 {
10341 struct GeneratedVisitor;
10342
10343 impl serde::de::Visitor<'_> for GeneratedVisitor {
10344 type Value = GeneratedField;
10345
10346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10347 write!(formatter, "expected one of: {:?}", &FIELDS)
10348 }
10349
10350 #[allow(unused_variables)]
10351 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10352 where
10353 E: serde::de::Error,
10354 {
10355 match value {
10356 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
10357 "cascade" => Ok(GeneratedField::Cascade),
10358 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10359 }
10360 }
10361 }
10362 deserializer.deserialize_identifier(GeneratedVisitor)
10363 }
10364 }
10365 struct GeneratedVisitor;
10366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10367 type Value = DropViewRequest;
10368
10369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10370 formatter.write_str("struct ddl_service.DropViewRequest")
10371 }
10372
10373 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
10374 where
10375 V: serde::de::MapAccess<'de>,
10376 {
10377 let mut view_id__ = None;
10378 let mut cascade__ = None;
10379 while let Some(k) = map_.next_key()? {
10380 match k {
10381 GeneratedField::ViewId => {
10382 if view_id__.is_some() {
10383 return Err(serde::de::Error::duplicate_field("viewId"));
10384 }
10385 view_id__ =
10386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10387 ;
10388 }
10389 GeneratedField::Cascade => {
10390 if cascade__.is_some() {
10391 return Err(serde::de::Error::duplicate_field("cascade"));
10392 }
10393 cascade__ = Some(map_.next_value()?);
10394 }
10395 }
10396 }
10397 Ok(DropViewRequest {
10398 view_id: view_id__.unwrap_or_default(),
10399 cascade: cascade__.unwrap_or_default(),
10400 })
10401 }
10402 }
10403 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
10404 }
10405}
10406impl serde::Serialize for DropViewResponse {
10407 #[allow(deprecated)]
10408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10409 where
10410 S: serde::Serializer,
10411 {
10412 use serde::ser::SerializeStruct;
10413 let mut len = 0;
10414 if self.status.is_some() {
10415 len += 1;
10416 }
10417 if self.version.is_some() {
10418 len += 1;
10419 }
10420 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
10421 if let Some(v) = self.status.as_ref() {
10422 struct_ser.serialize_field("status", v)?;
10423 }
10424 if let Some(v) = self.version.as_ref() {
10425 struct_ser.serialize_field("version", v)?;
10426 }
10427 struct_ser.end()
10428 }
10429}
10430impl<'de> serde::Deserialize<'de> for DropViewResponse {
10431 #[allow(deprecated)]
10432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10433 where
10434 D: serde::Deserializer<'de>,
10435 {
10436 const FIELDS: &[&str] = &[
10437 "status",
10438 "version",
10439 ];
10440
10441 #[allow(clippy::enum_variant_names)]
10442 enum GeneratedField {
10443 Status,
10444 Version,
10445 }
10446 impl<'de> serde::Deserialize<'de> for GeneratedField {
10447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10448 where
10449 D: serde::Deserializer<'de>,
10450 {
10451 struct GeneratedVisitor;
10452
10453 impl serde::de::Visitor<'_> for GeneratedVisitor {
10454 type Value = GeneratedField;
10455
10456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10457 write!(formatter, "expected one of: {:?}", &FIELDS)
10458 }
10459
10460 #[allow(unused_variables)]
10461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10462 where
10463 E: serde::de::Error,
10464 {
10465 match value {
10466 "status" => Ok(GeneratedField::Status),
10467 "version" => Ok(GeneratedField::Version),
10468 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10469 }
10470 }
10471 }
10472 deserializer.deserialize_identifier(GeneratedVisitor)
10473 }
10474 }
10475 struct GeneratedVisitor;
10476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10477 type Value = DropViewResponse;
10478
10479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10480 formatter.write_str("struct ddl_service.DropViewResponse")
10481 }
10482
10483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
10484 where
10485 V: serde::de::MapAccess<'de>,
10486 {
10487 let mut status__ = None;
10488 let mut version__ = None;
10489 while let Some(k) = map_.next_key()? {
10490 match k {
10491 GeneratedField::Status => {
10492 if status__.is_some() {
10493 return Err(serde::de::Error::duplicate_field("status"));
10494 }
10495 status__ = map_.next_value()?;
10496 }
10497 GeneratedField::Version => {
10498 if version__.is_some() {
10499 return Err(serde::de::Error::duplicate_field("version"));
10500 }
10501 version__ = map_.next_value()?;
10502 }
10503 }
10504 }
10505 Ok(DropViewResponse {
10506 status: status__,
10507 version: version__,
10508 })
10509 }
10510 }
10511 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
10512 }
10513}
10514impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
10515 #[allow(deprecated)]
10516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10517 where
10518 S: serde::Serializer,
10519 {
10520 use serde::ser::SerializeStruct;
10521 let mut len = 0;
10522 if self.sink_id != 0 {
10523 len += 1;
10524 }
10525 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
10526 if self.sink_id != 0 {
10527 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10528 }
10529 struct_ser.end()
10530 }
10531}
10532impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10533 #[allow(deprecated)]
10534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10535 where
10536 D: serde::Deserializer<'de>,
10537 {
10538 const FIELDS: &[&str] = &[
10539 "sink_id",
10540 "sinkId",
10541 ];
10542
10543 #[allow(clippy::enum_variant_names)]
10544 enum GeneratedField {
10545 SinkId,
10546 }
10547 impl<'de> serde::Deserialize<'de> for GeneratedField {
10548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10549 where
10550 D: serde::Deserializer<'de>,
10551 {
10552 struct GeneratedVisitor;
10553
10554 impl serde::de::Visitor<'_> for GeneratedVisitor {
10555 type Value = GeneratedField;
10556
10557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10558 write!(formatter, "expected one of: {:?}", &FIELDS)
10559 }
10560
10561 #[allow(unused_variables)]
10562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10563 where
10564 E: serde::de::Error,
10565 {
10566 match value {
10567 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10569 }
10570 }
10571 }
10572 deserializer.deserialize_identifier(GeneratedVisitor)
10573 }
10574 }
10575 struct GeneratedVisitor;
10576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10577 type Value = ExpireIcebergTableSnapshotsRequest;
10578
10579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10580 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10581 }
10582
10583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10584 where
10585 V: serde::de::MapAccess<'de>,
10586 {
10587 let mut sink_id__ = None;
10588 while let Some(k) = map_.next_key()? {
10589 match k {
10590 GeneratedField::SinkId => {
10591 if sink_id__.is_some() {
10592 return Err(serde::de::Error::duplicate_field("sinkId"));
10593 }
10594 sink_id__ =
10595 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10596 ;
10597 }
10598 }
10599 }
10600 Ok(ExpireIcebergTableSnapshotsRequest {
10601 sink_id: sink_id__.unwrap_or_default(),
10602 })
10603 }
10604 }
10605 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10606 }
10607}
10608impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10609 #[allow(deprecated)]
10610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10611 where
10612 S: serde::Serializer,
10613 {
10614 use serde::ser::SerializeStruct;
10615 let mut len = 0;
10616 if self.status.is_some() {
10617 len += 1;
10618 }
10619 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10620 if let Some(v) = self.status.as_ref() {
10621 struct_ser.serialize_field("status", v)?;
10622 }
10623 struct_ser.end()
10624 }
10625}
10626impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10627 #[allow(deprecated)]
10628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10629 where
10630 D: serde::Deserializer<'de>,
10631 {
10632 const FIELDS: &[&str] = &[
10633 "status",
10634 ];
10635
10636 #[allow(clippy::enum_variant_names)]
10637 enum GeneratedField {
10638 Status,
10639 }
10640 impl<'de> serde::Deserialize<'de> for GeneratedField {
10641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10642 where
10643 D: serde::Deserializer<'de>,
10644 {
10645 struct GeneratedVisitor;
10646
10647 impl serde::de::Visitor<'_> for GeneratedVisitor {
10648 type Value = GeneratedField;
10649
10650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10651 write!(formatter, "expected one of: {:?}", &FIELDS)
10652 }
10653
10654 #[allow(unused_variables)]
10655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10656 where
10657 E: serde::de::Error,
10658 {
10659 match value {
10660 "status" => Ok(GeneratedField::Status),
10661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10662 }
10663 }
10664 }
10665 deserializer.deserialize_identifier(GeneratedVisitor)
10666 }
10667 }
10668 struct GeneratedVisitor;
10669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10670 type Value = ExpireIcebergTableSnapshotsResponse;
10671
10672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10673 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10674 }
10675
10676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10677 where
10678 V: serde::de::MapAccess<'de>,
10679 {
10680 let mut status__ = None;
10681 while let Some(k) = map_.next_key()? {
10682 match k {
10683 GeneratedField::Status => {
10684 if status__.is_some() {
10685 return Err(serde::de::Error::duplicate_field("status"));
10686 }
10687 status__ = map_.next_value()?;
10688 }
10689 }
10690 }
10691 Ok(ExpireIcebergTableSnapshotsResponse {
10692 status: status__,
10693 })
10694 }
10695 }
10696 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10697 }
10698}
10699impl serde::Serialize for GetDdlProgressRequest {
10700 #[allow(deprecated)]
10701 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10702 where
10703 S: serde::Serializer,
10704 {
10705 use serde::ser::SerializeStruct;
10706 let len = 0;
10707 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10708 struct_ser.end()
10709 }
10710}
10711impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10712 #[allow(deprecated)]
10713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10714 where
10715 D: serde::Deserializer<'de>,
10716 {
10717 const FIELDS: &[&str] = &[
10718 ];
10719
10720 #[allow(clippy::enum_variant_names)]
10721 enum GeneratedField {
10722 }
10723 impl<'de> serde::Deserialize<'de> for GeneratedField {
10724 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10725 where
10726 D: serde::Deserializer<'de>,
10727 {
10728 struct GeneratedVisitor;
10729
10730 impl serde::de::Visitor<'_> for GeneratedVisitor {
10731 type Value = GeneratedField;
10732
10733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10734 write!(formatter, "expected one of: {:?}", &FIELDS)
10735 }
10736
10737 #[allow(unused_variables)]
10738 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10739 where
10740 E: serde::de::Error,
10741 {
10742 Err(serde::de::Error::unknown_field(value, FIELDS))
10743 }
10744 }
10745 deserializer.deserialize_identifier(GeneratedVisitor)
10746 }
10747 }
10748 struct GeneratedVisitor;
10749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10750 type Value = GetDdlProgressRequest;
10751
10752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10753 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
10754 }
10755
10756 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
10757 where
10758 V: serde::de::MapAccess<'de>,
10759 {
10760 while map_.next_key::<GeneratedField>()?.is_some() {
10761 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10762 }
10763 Ok(GetDdlProgressRequest {
10764 })
10765 }
10766 }
10767 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
10768 }
10769}
10770impl serde::Serialize for GetDdlProgressResponse {
10771 #[allow(deprecated)]
10772 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10773 where
10774 S: serde::Serializer,
10775 {
10776 use serde::ser::SerializeStruct;
10777 let mut len = 0;
10778 if !self.ddl_progress.is_empty() {
10779 len += 1;
10780 }
10781 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
10782 if !self.ddl_progress.is_empty() {
10783 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
10784 }
10785 struct_ser.end()
10786 }
10787}
10788impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
10789 #[allow(deprecated)]
10790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10791 where
10792 D: serde::Deserializer<'de>,
10793 {
10794 const FIELDS: &[&str] = &[
10795 "ddl_progress",
10796 "ddlProgress",
10797 ];
10798
10799 #[allow(clippy::enum_variant_names)]
10800 enum GeneratedField {
10801 DdlProgress,
10802 }
10803 impl<'de> serde::Deserialize<'de> for GeneratedField {
10804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10805 where
10806 D: serde::Deserializer<'de>,
10807 {
10808 struct GeneratedVisitor;
10809
10810 impl serde::de::Visitor<'_> for GeneratedVisitor {
10811 type Value = GeneratedField;
10812
10813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10814 write!(formatter, "expected one of: {:?}", &FIELDS)
10815 }
10816
10817 #[allow(unused_variables)]
10818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10819 where
10820 E: serde::de::Error,
10821 {
10822 match value {
10823 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10825 }
10826 }
10827 }
10828 deserializer.deserialize_identifier(GeneratedVisitor)
10829 }
10830 }
10831 struct GeneratedVisitor;
10832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10833 type Value = GetDdlProgressResponse;
10834
10835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10836 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10837 }
10838
10839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10840 where
10841 V: serde::de::MapAccess<'de>,
10842 {
10843 let mut ddl_progress__ = None;
10844 while let Some(k) = map_.next_key()? {
10845 match k {
10846 GeneratedField::DdlProgress => {
10847 if ddl_progress__.is_some() {
10848 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10849 }
10850 ddl_progress__ = Some(map_.next_value()?);
10851 }
10852 }
10853 }
10854 Ok(GetDdlProgressResponse {
10855 ddl_progress: ddl_progress__.unwrap_or_default(),
10856 })
10857 }
10858 }
10859 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10860 }
10861}
10862impl serde::Serialize for GetTableRequest {
10863 #[allow(deprecated)]
10864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10865 where
10866 S: serde::Serializer,
10867 {
10868 use serde::ser::SerializeStruct;
10869 let mut len = 0;
10870 if !self.database_name.is_empty() {
10871 len += 1;
10872 }
10873 if !self.table_name.is_empty() {
10874 len += 1;
10875 }
10876 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10877 if !self.database_name.is_empty() {
10878 struct_ser.serialize_field("databaseName", &self.database_name)?;
10879 }
10880 if !self.table_name.is_empty() {
10881 struct_ser.serialize_field("tableName", &self.table_name)?;
10882 }
10883 struct_ser.end()
10884 }
10885}
10886impl<'de> serde::Deserialize<'de> for GetTableRequest {
10887 #[allow(deprecated)]
10888 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10889 where
10890 D: serde::Deserializer<'de>,
10891 {
10892 const FIELDS: &[&str] = &[
10893 "database_name",
10894 "databaseName",
10895 "table_name",
10896 "tableName",
10897 ];
10898
10899 #[allow(clippy::enum_variant_names)]
10900 enum GeneratedField {
10901 DatabaseName,
10902 TableName,
10903 }
10904 impl<'de> serde::Deserialize<'de> for GeneratedField {
10905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10906 where
10907 D: serde::Deserializer<'de>,
10908 {
10909 struct GeneratedVisitor;
10910
10911 impl serde::de::Visitor<'_> for GeneratedVisitor {
10912 type Value = GeneratedField;
10913
10914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10915 write!(formatter, "expected one of: {:?}", &FIELDS)
10916 }
10917
10918 #[allow(unused_variables)]
10919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10920 where
10921 E: serde::de::Error,
10922 {
10923 match value {
10924 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10925 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10927 }
10928 }
10929 }
10930 deserializer.deserialize_identifier(GeneratedVisitor)
10931 }
10932 }
10933 struct GeneratedVisitor;
10934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10935 type Value = GetTableRequest;
10936
10937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10938 formatter.write_str("struct ddl_service.GetTableRequest")
10939 }
10940
10941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10942 where
10943 V: serde::de::MapAccess<'de>,
10944 {
10945 let mut database_name__ = None;
10946 let mut table_name__ = None;
10947 while let Some(k) = map_.next_key()? {
10948 match k {
10949 GeneratedField::DatabaseName => {
10950 if database_name__.is_some() {
10951 return Err(serde::de::Error::duplicate_field("databaseName"));
10952 }
10953 database_name__ = Some(map_.next_value()?);
10954 }
10955 GeneratedField::TableName => {
10956 if table_name__.is_some() {
10957 return Err(serde::de::Error::duplicate_field("tableName"));
10958 }
10959 table_name__ = Some(map_.next_value()?);
10960 }
10961 }
10962 }
10963 Ok(GetTableRequest {
10964 database_name: database_name__.unwrap_or_default(),
10965 table_name: table_name__.unwrap_or_default(),
10966 })
10967 }
10968 }
10969 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10970 }
10971}
10972impl serde::Serialize for GetTableResponse {
10973 #[allow(deprecated)]
10974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10975 where
10976 S: serde::Serializer,
10977 {
10978 use serde::ser::SerializeStruct;
10979 let mut len = 0;
10980 if self.table.is_some() {
10981 len += 1;
10982 }
10983 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10984 if let Some(v) = self.table.as_ref() {
10985 struct_ser.serialize_field("table", v)?;
10986 }
10987 struct_ser.end()
10988 }
10989}
10990impl<'de> serde::Deserialize<'de> for GetTableResponse {
10991 #[allow(deprecated)]
10992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10993 where
10994 D: serde::Deserializer<'de>,
10995 {
10996 const FIELDS: &[&str] = &[
10997 "table",
10998 ];
10999
11000 #[allow(clippy::enum_variant_names)]
11001 enum GeneratedField {
11002 Table,
11003 }
11004 impl<'de> serde::Deserialize<'de> for GeneratedField {
11005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11006 where
11007 D: serde::Deserializer<'de>,
11008 {
11009 struct GeneratedVisitor;
11010
11011 impl serde::de::Visitor<'_> for GeneratedVisitor {
11012 type Value = GeneratedField;
11013
11014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11015 write!(formatter, "expected one of: {:?}", &FIELDS)
11016 }
11017
11018 #[allow(unused_variables)]
11019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11020 where
11021 E: serde::de::Error,
11022 {
11023 match value {
11024 "table" => Ok(GeneratedField::Table),
11025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11026 }
11027 }
11028 }
11029 deserializer.deserialize_identifier(GeneratedVisitor)
11030 }
11031 }
11032 struct GeneratedVisitor;
11033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11034 type Value = GetTableResponse;
11035
11036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11037 formatter.write_str("struct ddl_service.GetTableResponse")
11038 }
11039
11040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
11041 where
11042 V: serde::de::MapAccess<'de>,
11043 {
11044 let mut table__ = None;
11045 while let Some(k) = map_.next_key()? {
11046 match k {
11047 GeneratedField::Table => {
11048 if table__.is_some() {
11049 return Err(serde::de::Error::duplicate_field("table"));
11050 }
11051 table__ = map_.next_value()?;
11052 }
11053 }
11054 }
11055 Ok(GetTableResponse {
11056 table: table__,
11057 })
11058 }
11059 }
11060 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
11061 }
11062}
11063impl serde::Serialize for GetTablesRequest {
11064 #[allow(deprecated)]
11065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11066 where
11067 S: serde::Serializer,
11068 {
11069 use serde::ser::SerializeStruct;
11070 let mut len = 0;
11071 if !self.table_ids.is_empty() {
11072 len += 1;
11073 }
11074 if self.include_dropped_tables {
11075 len += 1;
11076 }
11077 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
11078 if !self.table_ids.is_empty() {
11079 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11080 }
11081 if self.include_dropped_tables {
11082 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
11083 }
11084 struct_ser.end()
11085 }
11086}
11087impl<'de> serde::Deserialize<'de> for GetTablesRequest {
11088 #[allow(deprecated)]
11089 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11090 where
11091 D: serde::Deserializer<'de>,
11092 {
11093 const FIELDS: &[&str] = &[
11094 "table_ids",
11095 "tableIds",
11096 "include_dropped_tables",
11097 "includeDroppedTables",
11098 ];
11099
11100 #[allow(clippy::enum_variant_names)]
11101 enum GeneratedField {
11102 TableIds,
11103 IncludeDroppedTables,
11104 }
11105 impl<'de> serde::Deserialize<'de> for GeneratedField {
11106 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11107 where
11108 D: serde::Deserializer<'de>,
11109 {
11110 struct GeneratedVisitor;
11111
11112 impl serde::de::Visitor<'_> for GeneratedVisitor {
11113 type Value = GeneratedField;
11114
11115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11116 write!(formatter, "expected one of: {:?}", &FIELDS)
11117 }
11118
11119 #[allow(unused_variables)]
11120 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11121 where
11122 E: serde::de::Error,
11123 {
11124 match value {
11125 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11126 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
11127 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11128 }
11129 }
11130 }
11131 deserializer.deserialize_identifier(GeneratedVisitor)
11132 }
11133 }
11134 struct GeneratedVisitor;
11135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11136 type Value = GetTablesRequest;
11137
11138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11139 formatter.write_str("struct ddl_service.GetTablesRequest")
11140 }
11141
11142 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
11143 where
11144 V: serde::de::MapAccess<'de>,
11145 {
11146 let mut table_ids__ = None;
11147 let mut include_dropped_tables__ = None;
11148 while let Some(k) = map_.next_key()? {
11149 match k {
11150 GeneratedField::TableIds => {
11151 if table_ids__.is_some() {
11152 return Err(serde::de::Error::duplicate_field("tableIds"));
11153 }
11154 table_ids__ =
11155 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11156 .into_iter().map(|x| x.0).collect())
11157 ;
11158 }
11159 GeneratedField::IncludeDroppedTables => {
11160 if include_dropped_tables__.is_some() {
11161 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
11162 }
11163 include_dropped_tables__ = Some(map_.next_value()?);
11164 }
11165 }
11166 }
11167 Ok(GetTablesRequest {
11168 table_ids: table_ids__.unwrap_or_default(),
11169 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
11170 })
11171 }
11172 }
11173 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
11174 }
11175}
11176impl serde::Serialize for GetTablesResponse {
11177 #[allow(deprecated)]
11178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11179 where
11180 S: serde::Serializer,
11181 {
11182 use serde::ser::SerializeStruct;
11183 let mut len = 0;
11184 if !self.tables.is_empty() {
11185 len += 1;
11186 }
11187 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
11188 if !self.tables.is_empty() {
11189 struct_ser.serialize_field("tables", &self.tables)?;
11190 }
11191 struct_ser.end()
11192 }
11193}
11194impl<'de> serde::Deserialize<'de> for GetTablesResponse {
11195 #[allow(deprecated)]
11196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11197 where
11198 D: serde::Deserializer<'de>,
11199 {
11200 const FIELDS: &[&str] = &[
11201 "tables",
11202 ];
11203
11204 #[allow(clippy::enum_variant_names)]
11205 enum GeneratedField {
11206 Tables,
11207 }
11208 impl<'de> serde::Deserialize<'de> for GeneratedField {
11209 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11210 where
11211 D: serde::Deserializer<'de>,
11212 {
11213 struct GeneratedVisitor;
11214
11215 impl serde::de::Visitor<'_> for GeneratedVisitor {
11216 type Value = GeneratedField;
11217
11218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11219 write!(formatter, "expected one of: {:?}", &FIELDS)
11220 }
11221
11222 #[allow(unused_variables)]
11223 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11224 where
11225 E: serde::de::Error,
11226 {
11227 match value {
11228 "tables" => Ok(GeneratedField::Tables),
11229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11230 }
11231 }
11232 }
11233 deserializer.deserialize_identifier(GeneratedVisitor)
11234 }
11235 }
11236 struct GeneratedVisitor;
11237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11238 type Value = GetTablesResponse;
11239
11240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11241 formatter.write_str("struct ddl_service.GetTablesResponse")
11242 }
11243
11244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
11245 where
11246 V: serde::de::MapAccess<'de>,
11247 {
11248 let mut tables__ = None;
11249 while let Some(k) = map_.next_key()? {
11250 match k {
11251 GeneratedField::Tables => {
11252 if tables__.is_some() {
11253 return Err(serde::de::Error::duplicate_field("tables"));
11254 }
11255 tables__ = Some(
11256 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11257 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11258 );
11259 }
11260 }
11261 }
11262 Ok(GetTablesResponse {
11263 tables: tables__.unwrap_or_default(),
11264 })
11265 }
11266 }
11267 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
11268 }
11269}
11270impl serde::Serialize for ListConnectionsRequest {
11271 #[allow(deprecated)]
11272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11273 where
11274 S: serde::Serializer,
11275 {
11276 use serde::ser::SerializeStruct;
11277 let len = 0;
11278 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
11279 struct_ser.end()
11280 }
11281}
11282impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
11283 #[allow(deprecated)]
11284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11285 where
11286 D: serde::Deserializer<'de>,
11287 {
11288 const FIELDS: &[&str] = &[
11289 ];
11290
11291 #[allow(clippy::enum_variant_names)]
11292 enum GeneratedField {
11293 }
11294 impl<'de> serde::Deserialize<'de> for GeneratedField {
11295 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11296 where
11297 D: serde::Deserializer<'de>,
11298 {
11299 struct GeneratedVisitor;
11300
11301 impl serde::de::Visitor<'_> for GeneratedVisitor {
11302 type Value = GeneratedField;
11303
11304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11305 write!(formatter, "expected one of: {:?}", &FIELDS)
11306 }
11307
11308 #[allow(unused_variables)]
11309 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11310 where
11311 E: serde::de::Error,
11312 {
11313 Err(serde::de::Error::unknown_field(value, FIELDS))
11314 }
11315 }
11316 deserializer.deserialize_identifier(GeneratedVisitor)
11317 }
11318 }
11319 struct GeneratedVisitor;
11320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11321 type Value = ListConnectionsRequest;
11322
11323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11324 formatter.write_str("struct ddl_service.ListConnectionsRequest")
11325 }
11326
11327 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
11328 where
11329 V: serde::de::MapAccess<'de>,
11330 {
11331 while map_.next_key::<GeneratedField>()?.is_some() {
11332 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11333 }
11334 Ok(ListConnectionsRequest {
11335 })
11336 }
11337 }
11338 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
11339 }
11340}
11341impl serde::Serialize for ListConnectionsResponse {
11342 #[allow(deprecated)]
11343 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11344 where
11345 S: serde::Serializer,
11346 {
11347 use serde::ser::SerializeStruct;
11348 let mut len = 0;
11349 if !self.connections.is_empty() {
11350 len += 1;
11351 }
11352 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
11353 if !self.connections.is_empty() {
11354 struct_ser.serialize_field("connections", &self.connections)?;
11355 }
11356 struct_ser.end()
11357 }
11358}
11359impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
11360 #[allow(deprecated)]
11361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11362 where
11363 D: serde::Deserializer<'de>,
11364 {
11365 const FIELDS: &[&str] = &[
11366 "connections",
11367 ];
11368
11369 #[allow(clippy::enum_variant_names)]
11370 enum GeneratedField {
11371 Connections,
11372 }
11373 impl<'de> serde::Deserialize<'de> for GeneratedField {
11374 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11375 where
11376 D: serde::Deserializer<'de>,
11377 {
11378 struct GeneratedVisitor;
11379
11380 impl serde::de::Visitor<'_> for GeneratedVisitor {
11381 type Value = GeneratedField;
11382
11383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11384 write!(formatter, "expected one of: {:?}", &FIELDS)
11385 }
11386
11387 #[allow(unused_variables)]
11388 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11389 where
11390 E: serde::de::Error,
11391 {
11392 match value {
11393 "connections" => Ok(GeneratedField::Connections),
11394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11395 }
11396 }
11397 }
11398 deserializer.deserialize_identifier(GeneratedVisitor)
11399 }
11400 }
11401 struct GeneratedVisitor;
11402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11403 type Value = ListConnectionsResponse;
11404
11405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11406 formatter.write_str("struct ddl_service.ListConnectionsResponse")
11407 }
11408
11409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
11410 where
11411 V: serde::de::MapAccess<'de>,
11412 {
11413 let mut connections__ = None;
11414 while let Some(k) = map_.next_key()? {
11415 match k {
11416 GeneratedField::Connections => {
11417 if connections__.is_some() {
11418 return Err(serde::de::Error::duplicate_field("connections"));
11419 }
11420 connections__ = Some(map_.next_value()?);
11421 }
11422 }
11423 }
11424 Ok(ListConnectionsResponse {
11425 connections: connections__.unwrap_or_default(),
11426 })
11427 }
11428 }
11429 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
11430 }
11431}
11432impl serde::Serialize for ReplaceJobPlan {
11433 #[allow(deprecated)]
11434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11435 where
11436 S: serde::Serializer,
11437 {
11438 use serde::ser::SerializeStruct;
11439 let mut len = 0;
11440 if self.fragment_graph.is_some() {
11441 len += 1;
11442 }
11443 if self.replace_job.is_some() {
11444 len += 1;
11445 }
11446 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
11447 if let Some(v) = self.fragment_graph.as_ref() {
11448 struct_ser.serialize_field("fragmentGraph", v)?;
11449 }
11450 if let Some(v) = self.replace_job.as_ref() {
11451 match v {
11452 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
11453 struct_ser.serialize_field("replaceTable", v)?;
11454 }
11455 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
11456 struct_ser.serialize_field("replaceSource", v)?;
11457 }
11458 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
11459 struct_ser.serialize_field("replaceMaterializedView", v)?;
11460 }
11461 }
11462 }
11463 struct_ser.end()
11464 }
11465}
11466impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
11467 #[allow(deprecated)]
11468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11469 where
11470 D: serde::Deserializer<'de>,
11471 {
11472 const FIELDS: &[&str] = &[
11473 "fragment_graph",
11474 "fragmentGraph",
11475 "replace_table",
11476 "replaceTable",
11477 "replace_source",
11478 "replaceSource",
11479 "replace_materialized_view",
11480 "replaceMaterializedView",
11481 ];
11482
11483 #[allow(clippy::enum_variant_names)]
11484 enum GeneratedField {
11485 FragmentGraph,
11486 ReplaceTable,
11487 ReplaceSource,
11488 ReplaceMaterializedView,
11489 }
11490 impl<'de> serde::Deserialize<'de> for GeneratedField {
11491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11492 where
11493 D: serde::Deserializer<'de>,
11494 {
11495 struct GeneratedVisitor;
11496
11497 impl serde::de::Visitor<'_> for GeneratedVisitor {
11498 type Value = GeneratedField;
11499
11500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11501 write!(formatter, "expected one of: {:?}", &FIELDS)
11502 }
11503
11504 #[allow(unused_variables)]
11505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11506 where
11507 E: serde::de::Error,
11508 {
11509 match value {
11510 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
11511 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
11512 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
11513 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
11514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11515 }
11516 }
11517 }
11518 deserializer.deserialize_identifier(GeneratedVisitor)
11519 }
11520 }
11521 struct GeneratedVisitor;
11522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11523 type Value = ReplaceJobPlan;
11524
11525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11526 formatter.write_str("struct ddl_service.ReplaceJobPlan")
11527 }
11528
11529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
11530 where
11531 V: serde::de::MapAccess<'de>,
11532 {
11533 let mut fragment_graph__ = None;
11534 let mut replace_job__ = None;
11535 while let Some(k) = map_.next_key()? {
11536 match k {
11537 GeneratedField::FragmentGraph => {
11538 if fragment_graph__.is_some() {
11539 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11540 }
11541 fragment_graph__ = map_.next_value()?;
11542 }
11543 GeneratedField::ReplaceTable => {
11544 if replace_job__.is_some() {
11545 return Err(serde::de::Error::duplicate_field("replaceTable"));
11546 }
11547 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11548;
11549 }
11550 GeneratedField::ReplaceSource => {
11551 if replace_job__.is_some() {
11552 return Err(serde::de::Error::duplicate_field("replaceSource"));
11553 }
11554 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11555;
11556 }
11557 GeneratedField::ReplaceMaterializedView => {
11558 if replace_job__.is_some() {
11559 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11560 }
11561 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11562;
11563 }
11564 }
11565 }
11566 Ok(ReplaceJobPlan {
11567 fragment_graph: fragment_graph__,
11568 replace_job: replace_job__,
11569 })
11570 }
11571 }
11572 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11573 }
11574}
11575impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
11576 #[allow(deprecated)]
11577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11578 where
11579 S: serde::Serializer,
11580 {
11581 use serde::ser::SerializeStruct;
11582 let mut len = 0;
11583 if self.table.is_some() {
11584 len += 1;
11585 }
11586 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11587 if let Some(v) = self.table.as_ref() {
11588 struct_ser.serialize_field("table", v)?;
11589 }
11590 struct_ser.end()
11591 }
11592}
11593impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
11594 #[allow(deprecated)]
11595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11596 where
11597 D: serde::Deserializer<'de>,
11598 {
11599 const FIELDS: &[&str] = &[
11600 "table",
11601 ];
11602
11603 #[allow(clippy::enum_variant_names)]
11604 enum GeneratedField {
11605 Table,
11606 }
11607 impl<'de> serde::Deserialize<'de> for GeneratedField {
11608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11609 where
11610 D: serde::Deserializer<'de>,
11611 {
11612 struct GeneratedVisitor;
11613
11614 impl serde::de::Visitor<'_> for GeneratedVisitor {
11615 type Value = GeneratedField;
11616
11617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11618 write!(formatter, "expected one of: {:?}", &FIELDS)
11619 }
11620
11621 #[allow(unused_variables)]
11622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11623 where
11624 E: serde::de::Error,
11625 {
11626 match value {
11627 "table" => Ok(GeneratedField::Table),
11628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11629 }
11630 }
11631 }
11632 deserializer.deserialize_identifier(GeneratedVisitor)
11633 }
11634 }
11635 struct GeneratedVisitor;
11636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11637 type Value = replace_job_plan::ReplaceMaterializedView;
11638
11639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11640 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11641 }
11642
11643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11644 where
11645 V: serde::de::MapAccess<'de>,
11646 {
11647 let mut table__ = None;
11648 while let Some(k) = map_.next_key()? {
11649 match k {
11650 GeneratedField::Table => {
11651 if table__.is_some() {
11652 return Err(serde::de::Error::duplicate_field("table"));
11653 }
11654 table__ = map_.next_value()?;
11655 }
11656 }
11657 }
11658 Ok(replace_job_plan::ReplaceMaterializedView {
11659 table: table__,
11660 })
11661 }
11662 }
11663 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11664 }
11665}
11666impl serde::Serialize for replace_job_plan::ReplaceSource {
11667 #[allow(deprecated)]
11668 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11669 where
11670 S: serde::Serializer,
11671 {
11672 use serde::ser::SerializeStruct;
11673 let mut len = 0;
11674 if self.source.is_some() {
11675 len += 1;
11676 }
11677 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11678 if let Some(v) = self.source.as_ref() {
11679 struct_ser.serialize_field("source", v)?;
11680 }
11681 struct_ser.end()
11682 }
11683}
11684impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11685 #[allow(deprecated)]
11686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11687 where
11688 D: serde::Deserializer<'de>,
11689 {
11690 const FIELDS: &[&str] = &[
11691 "source",
11692 ];
11693
11694 #[allow(clippy::enum_variant_names)]
11695 enum GeneratedField {
11696 Source,
11697 }
11698 impl<'de> serde::Deserialize<'de> for GeneratedField {
11699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11700 where
11701 D: serde::Deserializer<'de>,
11702 {
11703 struct GeneratedVisitor;
11704
11705 impl serde::de::Visitor<'_> for GeneratedVisitor {
11706 type Value = GeneratedField;
11707
11708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11709 write!(formatter, "expected one of: {:?}", &FIELDS)
11710 }
11711
11712 #[allow(unused_variables)]
11713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11714 where
11715 E: serde::de::Error,
11716 {
11717 match value {
11718 "source" => Ok(GeneratedField::Source),
11719 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11720 }
11721 }
11722 }
11723 deserializer.deserialize_identifier(GeneratedVisitor)
11724 }
11725 }
11726 struct GeneratedVisitor;
11727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11728 type Value = replace_job_plan::ReplaceSource;
11729
11730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11731 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
11732 }
11733
11734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
11735 where
11736 V: serde::de::MapAccess<'de>,
11737 {
11738 let mut source__ = None;
11739 while let Some(k) = map_.next_key()? {
11740 match k {
11741 GeneratedField::Source => {
11742 if source__.is_some() {
11743 return Err(serde::de::Error::duplicate_field("source"));
11744 }
11745 source__ = map_.next_value()?;
11746 }
11747 }
11748 }
11749 Ok(replace_job_plan::ReplaceSource {
11750 source: source__,
11751 })
11752 }
11753 }
11754 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
11755 }
11756}
11757impl serde::Serialize for replace_job_plan::ReplaceTable {
11758 #[allow(deprecated)]
11759 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11760 where
11761 S: serde::Serializer,
11762 {
11763 use serde::ser::SerializeStruct;
11764 let mut len = 0;
11765 if self.table.is_some() {
11766 len += 1;
11767 }
11768 if self.source.is_some() {
11769 len += 1;
11770 }
11771 if self.job_type != 0 {
11772 len += 1;
11773 }
11774 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
11775 if let Some(v) = self.table.as_ref() {
11776 struct_ser.serialize_field("table", v)?;
11777 }
11778 if let Some(v) = self.source.as_ref() {
11779 struct_ser.serialize_field("source", v)?;
11780 }
11781 if self.job_type != 0 {
11782 let v = TableJobType::try_from(self.job_type)
11783 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
11784 struct_ser.serialize_field("jobType", &v)?;
11785 }
11786 struct_ser.end()
11787 }
11788}
11789impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
11790 #[allow(deprecated)]
11791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11792 where
11793 D: serde::Deserializer<'de>,
11794 {
11795 const FIELDS: &[&str] = &[
11796 "table",
11797 "source",
11798 "job_type",
11799 "jobType",
11800 ];
11801
11802 #[allow(clippy::enum_variant_names)]
11803 enum GeneratedField {
11804 Table,
11805 Source,
11806 JobType,
11807 }
11808 impl<'de> serde::Deserialize<'de> for GeneratedField {
11809 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11810 where
11811 D: serde::Deserializer<'de>,
11812 {
11813 struct GeneratedVisitor;
11814
11815 impl serde::de::Visitor<'_> for GeneratedVisitor {
11816 type Value = GeneratedField;
11817
11818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11819 write!(formatter, "expected one of: {:?}", &FIELDS)
11820 }
11821
11822 #[allow(unused_variables)]
11823 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11824 where
11825 E: serde::de::Error,
11826 {
11827 match value {
11828 "table" => Ok(GeneratedField::Table),
11829 "source" => Ok(GeneratedField::Source),
11830 "jobType" | "job_type" => Ok(GeneratedField::JobType),
11831 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11832 }
11833 }
11834 }
11835 deserializer.deserialize_identifier(GeneratedVisitor)
11836 }
11837 }
11838 struct GeneratedVisitor;
11839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11840 type Value = replace_job_plan::ReplaceTable;
11841
11842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11843 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11844 }
11845
11846 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11847 where
11848 V: serde::de::MapAccess<'de>,
11849 {
11850 let mut table__ = None;
11851 let mut source__ = None;
11852 let mut job_type__ = None;
11853 while let Some(k) = map_.next_key()? {
11854 match k {
11855 GeneratedField::Table => {
11856 if table__.is_some() {
11857 return Err(serde::de::Error::duplicate_field("table"));
11858 }
11859 table__ = map_.next_value()?;
11860 }
11861 GeneratedField::Source => {
11862 if source__.is_some() {
11863 return Err(serde::de::Error::duplicate_field("source"));
11864 }
11865 source__ = map_.next_value()?;
11866 }
11867 GeneratedField::JobType => {
11868 if job_type__.is_some() {
11869 return Err(serde::de::Error::duplicate_field("jobType"));
11870 }
11871 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11872 }
11873 }
11874 }
11875 Ok(replace_job_plan::ReplaceTable {
11876 table: table__,
11877 source: source__,
11878 job_type: job_type__.unwrap_or_default(),
11879 })
11880 }
11881 }
11882 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11883 }
11884}
11885impl serde::Serialize for ReplaceJobPlanRequest {
11886 #[allow(deprecated)]
11887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11888 where
11889 S: serde::Serializer,
11890 {
11891 use serde::ser::SerializeStruct;
11892 let mut len = 0;
11893 if self.plan.is_some() {
11894 len += 1;
11895 }
11896 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11897 if let Some(v) = self.plan.as_ref() {
11898 struct_ser.serialize_field("plan", v)?;
11899 }
11900 struct_ser.end()
11901 }
11902}
11903impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11904 #[allow(deprecated)]
11905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11906 where
11907 D: serde::Deserializer<'de>,
11908 {
11909 const FIELDS: &[&str] = &[
11910 "plan",
11911 ];
11912
11913 #[allow(clippy::enum_variant_names)]
11914 enum GeneratedField {
11915 Plan,
11916 }
11917 impl<'de> serde::Deserialize<'de> for GeneratedField {
11918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11919 where
11920 D: serde::Deserializer<'de>,
11921 {
11922 struct GeneratedVisitor;
11923
11924 impl serde::de::Visitor<'_> for GeneratedVisitor {
11925 type Value = GeneratedField;
11926
11927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11928 write!(formatter, "expected one of: {:?}", &FIELDS)
11929 }
11930
11931 #[allow(unused_variables)]
11932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11933 where
11934 E: serde::de::Error,
11935 {
11936 match value {
11937 "plan" => Ok(GeneratedField::Plan),
11938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11939 }
11940 }
11941 }
11942 deserializer.deserialize_identifier(GeneratedVisitor)
11943 }
11944 }
11945 struct GeneratedVisitor;
11946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11947 type Value = ReplaceJobPlanRequest;
11948
11949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11950 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11951 }
11952
11953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11954 where
11955 V: serde::de::MapAccess<'de>,
11956 {
11957 let mut plan__ = None;
11958 while let Some(k) = map_.next_key()? {
11959 match k {
11960 GeneratedField::Plan => {
11961 if plan__.is_some() {
11962 return Err(serde::de::Error::duplicate_field("plan"));
11963 }
11964 plan__ = map_.next_value()?;
11965 }
11966 }
11967 }
11968 Ok(ReplaceJobPlanRequest {
11969 plan: plan__,
11970 })
11971 }
11972 }
11973 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11974 }
11975}
11976impl serde::Serialize for ReplaceJobPlanResponse {
11977 #[allow(deprecated)]
11978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11979 where
11980 S: serde::Serializer,
11981 {
11982 use serde::ser::SerializeStruct;
11983 let mut len = 0;
11984 if self.status.is_some() {
11985 len += 1;
11986 }
11987 if self.version.is_some() {
11988 len += 1;
11989 }
11990 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11991 if let Some(v) = self.status.as_ref() {
11992 struct_ser.serialize_field("status", v)?;
11993 }
11994 if let Some(v) = self.version.as_ref() {
11995 struct_ser.serialize_field("version", v)?;
11996 }
11997 struct_ser.end()
11998 }
11999}
12000impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
12001 #[allow(deprecated)]
12002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12003 where
12004 D: serde::Deserializer<'de>,
12005 {
12006 const FIELDS: &[&str] = &[
12007 "status",
12008 "version",
12009 ];
12010
12011 #[allow(clippy::enum_variant_names)]
12012 enum GeneratedField {
12013 Status,
12014 Version,
12015 }
12016 impl<'de> serde::Deserialize<'de> for GeneratedField {
12017 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12018 where
12019 D: serde::Deserializer<'de>,
12020 {
12021 struct GeneratedVisitor;
12022
12023 impl serde::de::Visitor<'_> for GeneratedVisitor {
12024 type Value = GeneratedField;
12025
12026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12027 write!(formatter, "expected one of: {:?}", &FIELDS)
12028 }
12029
12030 #[allow(unused_variables)]
12031 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12032 where
12033 E: serde::de::Error,
12034 {
12035 match value {
12036 "status" => Ok(GeneratedField::Status),
12037 "version" => Ok(GeneratedField::Version),
12038 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12039 }
12040 }
12041 }
12042 deserializer.deserialize_identifier(GeneratedVisitor)
12043 }
12044 }
12045 struct GeneratedVisitor;
12046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12047 type Value = ReplaceJobPlanResponse;
12048
12049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12050 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
12051 }
12052
12053 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
12054 where
12055 V: serde::de::MapAccess<'de>,
12056 {
12057 let mut status__ = None;
12058 let mut version__ = None;
12059 while let Some(k) = map_.next_key()? {
12060 match k {
12061 GeneratedField::Status => {
12062 if status__.is_some() {
12063 return Err(serde::de::Error::duplicate_field("status"));
12064 }
12065 status__ = map_.next_value()?;
12066 }
12067 GeneratedField::Version => {
12068 if version__.is_some() {
12069 return Err(serde::de::Error::duplicate_field("version"));
12070 }
12071 version__ = map_.next_value()?;
12072 }
12073 }
12074 }
12075 Ok(ReplaceJobPlanResponse {
12076 status: status__,
12077 version: version__,
12078 })
12079 }
12080 }
12081 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
12082 }
12083}
12084impl serde::Serialize for ResetSourceRequest {
12085 #[allow(deprecated)]
12086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12087 where
12088 S: serde::Serializer,
12089 {
12090 use serde::ser::SerializeStruct;
12091 let mut len = 0;
12092 if self.source_id != 0 {
12093 len += 1;
12094 }
12095 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
12096 if self.source_id != 0 {
12097 struct_ser.serialize_field("sourceId", &self.source_id)?;
12098 }
12099 struct_ser.end()
12100 }
12101}
12102impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
12103 #[allow(deprecated)]
12104 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12105 where
12106 D: serde::Deserializer<'de>,
12107 {
12108 const FIELDS: &[&str] = &[
12109 "source_id",
12110 "sourceId",
12111 ];
12112
12113 #[allow(clippy::enum_variant_names)]
12114 enum GeneratedField {
12115 SourceId,
12116 }
12117 impl<'de> serde::Deserialize<'de> for GeneratedField {
12118 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12119 where
12120 D: serde::Deserializer<'de>,
12121 {
12122 struct GeneratedVisitor;
12123
12124 impl serde::de::Visitor<'_> for GeneratedVisitor {
12125 type Value = GeneratedField;
12126
12127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12128 write!(formatter, "expected one of: {:?}", &FIELDS)
12129 }
12130
12131 #[allow(unused_variables)]
12132 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12133 where
12134 E: serde::de::Error,
12135 {
12136 match value {
12137 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12138 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12139 }
12140 }
12141 }
12142 deserializer.deserialize_identifier(GeneratedVisitor)
12143 }
12144 }
12145 struct GeneratedVisitor;
12146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12147 type Value = ResetSourceRequest;
12148
12149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12150 formatter.write_str("struct ddl_service.ResetSourceRequest")
12151 }
12152
12153 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
12154 where
12155 V: serde::de::MapAccess<'de>,
12156 {
12157 let mut source_id__ = None;
12158 while let Some(k) = map_.next_key()? {
12159 match k {
12160 GeneratedField::SourceId => {
12161 if source_id__.is_some() {
12162 return Err(serde::de::Error::duplicate_field("sourceId"));
12163 }
12164 source_id__ =
12165 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12166 ;
12167 }
12168 }
12169 }
12170 Ok(ResetSourceRequest {
12171 source_id: source_id__.unwrap_or_default(),
12172 })
12173 }
12174 }
12175 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
12176 }
12177}
12178impl serde::Serialize for ResetSourceResponse {
12179 #[allow(deprecated)]
12180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12181 where
12182 S: serde::Serializer,
12183 {
12184 use serde::ser::SerializeStruct;
12185 let mut len = 0;
12186 if self.status.is_some() {
12187 len += 1;
12188 }
12189 if self.version.is_some() {
12190 len += 1;
12191 }
12192 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
12193 if let Some(v) = self.status.as_ref() {
12194 struct_ser.serialize_field("status", v)?;
12195 }
12196 if let Some(v) = self.version.as_ref() {
12197 struct_ser.serialize_field("version", v)?;
12198 }
12199 struct_ser.end()
12200 }
12201}
12202impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
12203 #[allow(deprecated)]
12204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12205 where
12206 D: serde::Deserializer<'de>,
12207 {
12208 const FIELDS: &[&str] = &[
12209 "status",
12210 "version",
12211 ];
12212
12213 #[allow(clippy::enum_variant_names)]
12214 enum GeneratedField {
12215 Status,
12216 Version,
12217 }
12218 impl<'de> serde::Deserialize<'de> for GeneratedField {
12219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12220 where
12221 D: serde::Deserializer<'de>,
12222 {
12223 struct GeneratedVisitor;
12224
12225 impl serde::de::Visitor<'_> for GeneratedVisitor {
12226 type Value = GeneratedField;
12227
12228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12229 write!(formatter, "expected one of: {:?}", &FIELDS)
12230 }
12231
12232 #[allow(unused_variables)]
12233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12234 where
12235 E: serde::de::Error,
12236 {
12237 match value {
12238 "status" => Ok(GeneratedField::Status),
12239 "version" => Ok(GeneratedField::Version),
12240 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12241 }
12242 }
12243 }
12244 deserializer.deserialize_identifier(GeneratedVisitor)
12245 }
12246 }
12247 struct GeneratedVisitor;
12248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12249 type Value = ResetSourceResponse;
12250
12251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12252 formatter.write_str("struct ddl_service.ResetSourceResponse")
12253 }
12254
12255 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
12256 where
12257 V: serde::de::MapAccess<'de>,
12258 {
12259 let mut status__ = None;
12260 let mut version__ = None;
12261 while let Some(k) = map_.next_key()? {
12262 match k {
12263 GeneratedField::Status => {
12264 if status__.is_some() {
12265 return Err(serde::de::Error::duplicate_field("status"));
12266 }
12267 status__ = map_.next_value()?;
12268 }
12269 GeneratedField::Version => {
12270 if version__.is_some() {
12271 return Err(serde::de::Error::duplicate_field("version"));
12272 }
12273 version__ = map_.next_value()?;
12274 }
12275 }
12276 }
12277 Ok(ResetSourceResponse {
12278 status: status__,
12279 version: version__,
12280 })
12281 }
12282 }
12283 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
12284 }
12285}
12286impl serde::Serialize for RisectlListStateTablesRequest {
12287 #[allow(deprecated)]
12288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12289 where
12290 S: serde::Serializer,
12291 {
12292 use serde::ser::SerializeStruct;
12293 let len = 0;
12294 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
12295 struct_ser.end()
12296 }
12297}
12298impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
12299 #[allow(deprecated)]
12300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12301 where
12302 D: serde::Deserializer<'de>,
12303 {
12304 const FIELDS: &[&str] = &[
12305 ];
12306
12307 #[allow(clippy::enum_variant_names)]
12308 enum GeneratedField {
12309 }
12310 impl<'de> serde::Deserialize<'de> for GeneratedField {
12311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12312 where
12313 D: serde::Deserializer<'de>,
12314 {
12315 struct GeneratedVisitor;
12316
12317 impl serde::de::Visitor<'_> for GeneratedVisitor {
12318 type Value = GeneratedField;
12319
12320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12321 write!(formatter, "expected one of: {:?}", &FIELDS)
12322 }
12323
12324 #[allow(unused_variables)]
12325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12326 where
12327 E: serde::de::Error,
12328 {
12329 Err(serde::de::Error::unknown_field(value, FIELDS))
12330 }
12331 }
12332 deserializer.deserialize_identifier(GeneratedVisitor)
12333 }
12334 }
12335 struct GeneratedVisitor;
12336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12337 type Value = RisectlListStateTablesRequest;
12338
12339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12340 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
12341 }
12342
12343 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
12344 where
12345 V: serde::de::MapAccess<'de>,
12346 {
12347 while map_.next_key::<GeneratedField>()?.is_some() {
12348 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12349 }
12350 Ok(RisectlListStateTablesRequest {
12351 })
12352 }
12353 }
12354 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
12355 }
12356}
12357impl serde::Serialize for RisectlListStateTablesResponse {
12358 #[allow(deprecated)]
12359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12360 where
12361 S: serde::Serializer,
12362 {
12363 use serde::ser::SerializeStruct;
12364 let mut len = 0;
12365 if !self.tables.is_empty() {
12366 len += 1;
12367 }
12368 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
12369 if !self.tables.is_empty() {
12370 struct_ser.serialize_field("tables", &self.tables)?;
12371 }
12372 struct_ser.end()
12373 }
12374}
12375impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
12376 #[allow(deprecated)]
12377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12378 where
12379 D: serde::Deserializer<'de>,
12380 {
12381 const FIELDS: &[&str] = &[
12382 "tables",
12383 ];
12384
12385 #[allow(clippy::enum_variant_names)]
12386 enum GeneratedField {
12387 Tables,
12388 }
12389 impl<'de> serde::Deserialize<'de> for GeneratedField {
12390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12391 where
12392 D: serde::Deserializer<'de>,
12393 {
12394 struct GeneratedVisitor;
12395
12396 impl serde::de::Visitor<'_> for GeneratedVisitor {
12397 type Value = GeneratedField;
12398
12399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12400 write!(formatter, "expected one of: {:?}", &FIELDS)
12401 }
12402
12403 #[allow(unused_variables)]
12404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12405 where
12406 E: serde::de::Error,
12407 {
12408 match value {
12409 "tables" => Ok(GeneratedField::Tables),
12410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12411 }
12412 }
12413 }
12414 deserializer.deserialize_identifier(GeneratedVisitor)
12415 }
12416 }
12417 struct GeneratedVisitor;
12418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12419 type Value = RisectlListStateTablesResponse;
12420
12421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12422 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
12423 }
12424
12425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
12426 where
12427 V: serde::de::MapAccess<'de>,
12428 {
12429 let mut tables__ = None;
12430 while let Some(k) = map_.next_key()? {
12431 match k {
12432 GeneratedField::Tables => {
12433 if tables__.is_some() {
12434 return Err(serde::de::Error::duplicate_field("tables"));
12435 }
12436 tables__ = Some(map_.next_value()?);
12437 }
12438 }
12439 }
12440 Ok(RisectlListStateTablesResponse {
12441 tables: tables__.unwrap_or_default(),
12442 })
12443 }
12444 }
12445 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
12446 }
12447}
12448impl serde::Serialize for RisectlResumeBackfillRequest {
12449 #[allow(deprecated)]
12450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12451 where
12452 S: serde::Serializer,
12453 {
12454 use serde::ser::SerializeStruct;
12455 let mut len = 0;
12456 if self.target.is_some() {
12457 len += 1;
12458 }
12459 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillRequest", len)?;
12460 if let Some(v) = self.target.as_ref() {
12461 match v {
12462 risectl_resume_backfill_request::Target::JobId(v) => {
12463 struct_ser.serialize_field("jobId", v)?;
12464 }
12465 risectl_resume_backfill_request::Target::FragmentId(v) => {
12466 struct_ser.serialize_field("fragmentId", v)?;
12467 }
12468 }
12469 }
12470 struct_ser.end()
12471 }
12472}
12473impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillRequest {
12474 #[allow(deprecated)]
12475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12476 where
12477 D: serde::Deserializer<'de>,
12478 {
12479 const FIELDS: &[&str] = &[
12480 "job_id",
12481 "jobId",
12482 "fragment_id",
12483 "fragmentId",
12484 ];
12485
12486 #[allow(clippy::enum_variant_names)]
12487 enum GeneratedField {
12488 JobId,
12489 FragmentId,
12490 }
12491 impl<'de> serde::Deserialize<'de> for GeneratedField {
12492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12493 where
12494 D: serde::Deserializer<'de>,
12495 {
12496 struct GeneratedVisitor;
12497
12498 impl serde::de::Visitor<'_> for GeneratedVisitor {
12499 type Value = GeneratedField;
12500
12501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12502 write!(formatter, "expected one of: {:?}", &FIELDS)
12503 }
12504
12505 #[allow(unused_variables)]
12506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12507 where
12508 E: serde::de::Error,
12509 {
12510 match value {
12511 "jobId" | "job_id" => Ok(GeneratedField::JobId),
12512 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12514 }
12515 }
12516 }
12517 deserializer.deserialize_identifier(GeneratedVisitor)
12518 }
12519 }
12520 struct GeneratedVisitor;
12521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12522 type Value = RisectlResumeBackfillRequest;
12523
12524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12525 formatter.write_str("struct ddl_service.RisectlResumeBackfillRequest")
12526 }
12527
12528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillRequest, V::Error>
12529 where
12530 V: serde::de::MapAccess<'de>,
12531 {
12532 let mut target__ = None;
12533 while let Some(k) = map_.next_key()? {
12534 match k {
12535 GeneratedField::JobId => {
12536 if target__.is_some() {
12537 return Err(serde::de::Error::duplicate_field("jobId"));
12538 }
12539 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::JobId(x.0));
12540 }
12541 GeneratedField::FragmentId => {
12542 if target__.is_some() {
12543 return Err(serde::de::Error::duplicate_field("fragmentId"));
12544 }
12545 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::FragmentId(x.0));
12546 }
12547 }
12548 }
12549 Ok(RisectlResumeBackfillRequest {
12550 target: target__,
12551 })
12552 }
12553 }
12554 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillRequest", FIELDS, GeneratedVisitor)
12555 }
12556}
12557impl serde::Serialize for RisectlResumeBackfillResponse {
12558 #[allow(deprecated)]
12559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12560 where
12561 S: serde::Serializer,
12562 {
12563 use serde::ser::SerializeStruct;
12564 let len = 0;
12565 let struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillResponse", len)?;
12566 struct_ser.end()
12567 }
12568}
12569impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillResponse {
12570 #[allow(deprecated)]
12571 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12572 where
12573 D: serde::Deserializer<'de>,
12574 {
12575 const FIELDS: &[&str] = &[
12576 ];
12577
12578 #[allow(clippy::enum_variant_names)]
12579 enum GeneratedField {
12580 }
12581 impl<'de> serde::Deserialize<'de> for GeneratedField {
12582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12583 where
12584 D: serde::Deserializer<'de>,
12585 {
12586 struct GeneratedVisitor;
12587
12588 impl serde::de::Visitor<'_> for GeneratedVisitor {
12589 type Value = GeneratedField;
12590
12591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12592 write!(formatter, "expected one of: {:?}", &FIELDS)
12593 }
12594
12595 #[allow(unused_variables)]
12596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12597 where
12598 E: serde::de::Error,
12599 {
12600 Err(serde::de::Error::unknown_field(value, FIELDS))
12601 }
12602 }
12603 deserializer.deserialize_identifier(GeneratedVisitor)
12604 }
12605 }
12606 struct GeneratedVisitor;
12607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12608 type Value = RisectlResumeBackfillResponse;
12609
12610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12611 formatter.write_str("struct ddl_service.RisectlResumeBackfillResponse")
12612 }
12613
12614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillResponse, V::Error>
12615 where
12616 V: serde::de::MapAccess<'de>,
12617 {
12618 while map_.next_key::<GeneratedField>()?.is_some() {
12619 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12620 }
12621 Ok(RisectlResumeBackfillResponse {
12622 })
12623 }
12624 }
12625 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillResponse", FIELDS, GeneratedVisitor)
12626 }
12627}
12628impl serde::Serialize for SchemaChangeEnvelope {
12629 #[allow(deprecated)]
12630 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12631 where
12632 S: serde::Serializer,
12633 {
12634 use serde::ser::SerializeStruct;
12635 let mut len = 0;
12636 if !self.table_changes.is_empty() {
12637 len += 1;
12638 }
12639 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
12640 if !self.table_changes.is_empty() {
12641 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
12642 }
12643 struct_ser.end()
12644 }
12645}
12646impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
12647 #[allow(deprecated)]
12648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12649 where
12650 D: serde::Deserializer<'de>,
12651 {
12652 const FIELDS: &[&str] = &[
12653 "table_changes",
12654 "tableChanges",
12655 ];
12656
12657 #[allow(clippy::enum_variant_names)]
12658 enum GeneratedField {
12659 TableChanges,
12660 }
12661 impl<'de> serde::Deserialize<'de> for GeneratedField {
12662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12663 where
12664 D: serde::Deserializer<'de>,
12665 {
12666 struct GeneratedVisitor;
12667
12668 impl serde::de::Visitor<'_> for GeneratedVisitor {
12669 type Value = GeneratedField;
12670
12671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12672 write!(formatter, "expected one of: {:?}", &FIELDS)
12673 }
12674
12675 #[allow(unused_variables)]
12676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12677 where
12678 E: serde::de::Error,
12679 {
12680 match value {
12681 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
12682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12683 }
12684 }
12685 }
12686 deserializer.deserialize_identifier(GeneratedVisitor)
12687 }
12688 }
12689 struct GeneratedVisitor;
12690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12691 type Value = SchemaChangeEnvelope;
12692
12693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12694 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
12695 }
12696
12697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
12698 where
12699 V: serde::de::MapAccess<'de>,
12700 {
12701 let mut table_changes__ = None;
12702 while let Some(k) = map_.next_key()? {
12703 match k {
12704 GeneratedField::TableChanges => {
12705 if table_changes__.is_some() {
12706 return Err(serde::de::Error::duplicate_field("tableChanges"));
12707 }
12708 table_changes__ = Some(map_.next_value()?);
12709 }
12710 }
12711 }
12712 Ok(SchemaChangeEnvelope {
12713 table_changes: table_changes__.unwrap_or_default(),
12714 })
12715 }
12716 }
12717 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
12718 }
12719}
12720impl serde::Serialize for StreamingJobResourceType {
12721 #[allow(deprecated)]
12722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12723 where
12724 S: serde::Serializer,
12725 {
12726 use serde::ser::SerializeStruct;
12727 let mut len = 0;
12728 if self.resource_type.is_some() {
12729 len += 1;
12730 }
12731 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
12732 if let Some(v) = self.resource_type.as_ref() {
12733 match v {
12734 streaming_job_resource_type::ResourceType::Regular(v) => {
12735 struct_ser.serialize_field("regular", v)?;
12736 }
12737 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
12738 struct_ser.serialize_field("specificResourceGroup", v)?;
12739 }
12740 streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup(v) => {
12741 struct_ser.serialize_field("serverlessBackfillResourceGroup", v)?;
12742 }
12743 }
12744 }
12745 struct_ser.end()
12746 }
12747}
12748impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
12749 #[allow(deprecated)]
12750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12751 where
12752 D: serde::Deserializer<'de>,
12753 {
12754 const FIELDS: &[&str] = &[
12755 "regular",
12756 "specific_resource_group",
12757 "specificResourceGroup",
12758 "serverless_backfill_resource_group",
12759 "serverlessBackfillResourceGroup",
12760 ];
12761
12762 #[allow(clippy::enum_variant_names)]
12763 enum GeneratedField {
12764 Regular,
12765 SpecificResourceGroup,
12766 ServerlessBackfillResourceGroup,
12767 }
12768 impl<'de> serde::Deserialize<'de> for GeneratedField {
12769 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12770 where
12771 D: serde::Deserializer<'de>,
12772 {
12773 struct GeneratedVisitor;
12774
12775 impl serde::de::Visitor<'_> for GeneratedVisitor {
12776 type Value = GeneratedField;
12777
12778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12779 write!(formatter, "expected one of: {:?}", &FIELDS)
12780 }
12781
12782 #[allow(unused_variables)]
12783 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12784 where
12785 E: serde::de::Error,
12786 {
12787 match value {
12788 "regular" => Ok(GeneratedField::Regular),
12789 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
12790 "serverlessBackfillResourceGroup" | "serverless_backfill_resource_group" => Ok(GeneratedField::ServerlessBackfillResourceGroup),
12791 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12792 }
12793 }
12794 }
12795 deserializer.deserialize_identifier(GeneratedVisitor)
12796 }
12797 }
12798 struct GeneratedVisitor;
12799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12800 type Value = StreamingJobResourceType;
12801
12802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12803 formatter.write_str("struct ddl_service.StreamingJobResourceType")
12804 }
12805
12806 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
12807 where
12808 V: serde::de::MapAccess<'de>,
12809 {
12810 let mut resource_type__ = None;
12811 while let Some(k) = map_.next_key()? {
12812 match k {
12813 GeneratedField::Regular => {
12814 if resource_type__.is_some() {
12815 return Err(serde::de::Error::duplicate_field("regular"));
12816 }
12817 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
12818 }
12819 GeneratedField::SpecificResourceGroup => {
12820 if resource_type__.is_some() {
12821 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
12822 }
12823 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
12824 }
12825 GeneratedField::ServerlessBackfillResourceGroup => {
12826 if resource_type__.is_some() {
12827 return Err(serde::de::Error::duplicate_field("serverlessBackfillResourceGroup"));
12828 }
12829 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup);
12830 }
12831 }
12832 }
12833 Ok(StreamingJobResourceType {
12834 resource_type: resource_type__,
12835 })
12836 }
12837 }
12838 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
12839 }
12840}
12841impl serde::Serialize for TableJobType {
12842 #[allow(deprecated)]
12843 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12844 where
12845 S: serde::Serializer,
12846 {
12847 let variant = match self {
12848 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
12849 Self::General => "TABLE_JOB_TYPE_GENERAL",
12850 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12851 };
12852 serializer.serialize_str(variant)
12853 }
12854}
12855impl<'de> serde::Deserialize<'de> for TableJobType {
12856 #[allow(deprecated)]
12857 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12858 where
12859 D: serde::Deserializer<'de>,
12860 {
12861 const FIELDS: &[&str] = &[
12862 "TABLE_JOB_TYPE_UNSPECIFIED",
12863 "TABLE_JOB_TYPE_GENERAL",
12864 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12865 ];
12866
12867 struct GeneratedVisitor;
12868
12869 impl serde::de::Visitor<'_> for GeneratedVisitor {
12870 type Value = TableJobType;
12871
12872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12873 write!(formatter, "expected one of: {:?}", &FIELDS)
12874 }
12875
12876 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12877 where
12878 E: serde::de::Error,
12879 {
12880 i32::try_from(v)
12881 .ok()
12882 .and_then(|x| x.try_into().ok())
12883 .ok_or_else(|| {
12884 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12885 })
12886 }
12887
12888 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12889 where
12890 E: serde::de::Error,
12891 {
12892 i32::try_from(v)
12893 .ok()
12894 .and_then(|x| x.try_into().ok())
12895 .ok_or_else(|| {
12896 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12897 })
12898 }
12899
12900 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12901 where
12902 E: serde::de::Error,
12903 {
12904 match value {
12905 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
12906 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
12907 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
12908 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12909 }
12910 }
12911 }
12912 deserializer.deserialize_any(GeneratedVisitor)
12913 }
12914}
12915impl serde::Serialize for TableSchemaChange {
12916 #[allow(deprecated)]
12917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12918 where
12919 S: serde::Serializer,
12920 {
12921 use serde::ser::SerializeStruct;
12922 let mut len = 0;
12923 if self.change_type != 0 {
12924 len += 1;
12925 }
12926 if !self.cdc_table_id.is_empty() {
12927 len += 1;
12928 }
12929 if !self.columns.is_empty() {
12930 len += 1;
12931 }
12932 if !self.upstream_ddl.is_empty() {
12933 len += 1;
12934 }
12935 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
12936 if self.change_type != 0 {
12937 let v = table_schema_change::TableChangeType::try_from(self.change_type)
12938 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
12939 struct_ser.serialize_field("changeType", &v)?;
12940 }
12941 if !self.cdc_table_id.is_empty() {
12942 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
12943 }
12944 if !self.columns.is_empty() {
12945 struct_ser.serialize_field("columns", &self.columns)?;
12946 }
12947 if !self.upstream_ddl.is_empty() {
12948 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
12949 }
12950 struct_ser.end()
12951 }
12952}
12953impl<'de> serde::Deserialize<'de> for TableSchemaChange {
12954 #[allow(deprecated)]
12955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12956 where
12957 D: serde::Deserializer<'de>,
12958 {
12959 const FIELDS: &[&str] = &[
12960 "change_type",
12961 "changeType",
12962 "cdc_table_id",
12963 "cdcTableId",
12964 "columns",
12965 "upstream_ddl",
12966 "upstreamDdl",
12967 ];
12968
12969 #[allow(clippy::enum_variant_names)]
12970 enum GeneratedField {
12971 ChangeType,
12972 CdcTableId,
12973 Columns,
12974 UpstreamDdl,
12975 }
12976 impl<'de> serde::Deserialize<'de> for GeneratedField {
12977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12978 where
12979 D: serde::Deserializer<'de>,
12980 {
12981 struct GeneratedVisitor;
12982
12983 impl serde::de::Visitor<'_> for GeneratedVisitor {
12984 type Value = GeneratedField;
12985
12986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12987 write!(formatter, "expected one of: {:?}", &FIELDS)
12988 }
12989
12990 #[allow(unused_variables)]
12991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12992 where
12993 E: serde::de::Error,
12994 {
12995 match value {
12996 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
12997 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
12998 "columns" => Ok(GeneratedField::Columns),
12999 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
13000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13001 }
13002 }
13003 }
13004 deserializer.deserialize_identifier(GeneratedVisitor)
13005 }
13006 }
13007 struct GeneratedVisitor;
13008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13009 type Value = TableSchemaChange;
13010
13011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13012 formatter.write_str("struct ddl_service.TableSchemaChange")
13013 }
13014
13015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
13016 where
13017 V: serde::de::MapAccess<'de>,
13018 {
13019 let mut change_type__ = None;
13020 let mut cdc_table_id__ = None;
13021 let mut columns__ = None;
13022 let mut upstream_ddl__ = None;
13023 while let Some(k) = map_.next_key()? {
13024 match k {
13025 GeneratedField::ChangeType => {
13026 if change_type__.is_some() {
13027 return Err(serde::de::Error::duplicate_field("changeType"));
13028 }
13029 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
13030 }
13031 GeneratedField::CdcTableId => {
13032 if cdc_table_id__.is_some() {
13033 return Err(serde::de::Error::duplicate_field("cdcTableId"));
13034 }
13035 cdc_table_id__ = Some(map_.next_value()?);
13036 }
13037 GeneratedField::Columns => {
13038 if columns__.is_some() {
13039 return Err(serde::de::Error::duplicate_field("columns"));
13040 }
13041 columns__ = Some(map_.next_value()?);
13042 }
13043 GeneratedField::UpstreamDdl => {
13044 if upstream_ddl__.is_some() {
13045 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
13046 }
13047 upstream_ddl__ = Some(map_.next_value()?);
13048 }
13049 }
13050 }
13051 Ok(TableSchemaChange {
13052 change_type: change_type__.unwrap_or_default(),
13053 cdc_table_id: cdc_table_id__.unwrap_or_default(),
13054 columns: columns__.unwrap_or_default(),
13055 upstream_ddl: upstream_ddl__.unwrap_or_default(),
13056 })
13057 }
13058 }
13059 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
13060 }
13061}
13062impl serde::Serialize for table_schema_change::TableChangeType {
13063 #[allow(deprecated)]
13064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13065 where
13066 S: serde::Serializer,
13067 {
13068 let variant = match self {
13069 Self::Unspecified => "UNSPECIFIED",
13070 Self::Alter => "ALTER",
13071 Self::Create => "CREATE",
13072 Self::Drop => "DROP",
13073 };
13074 serializer.serialize_str(variant)
13075 }
13076}
13077impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
13078 #[allow(deprecated)]
13079 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13080 where
13081 D: serde::Deserializer<'de>,
13082 {
13083 const FIELDS: &[&str] = &[
13084 "UNSPECIFIED",
13085 "ALTER",
13086 "CREATE",
13087 "DROP",
13088 ];
13089
13090 struct GeneratedVisitor;
13091
13092 impl serde::de::Visitor<'_> for GeneratedVisitor {
13093 type Value = table_schema_change::TableChangeType;
13094
13095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13096 write!(formatter, "expected one of: {:?}", &FIELDS)
13097 }
13098
13099 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13100 where
13101 E: serde::de::Error,
13102 {
13103 i32::try_from(v)
13104 .ok()
13105 .and_then(|x| x.try_into().ok())
13106 .ok_or_else(|| {
13107 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13108 })
13109 }
13110
13111 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13112 where
13113 E: serde::de::Error,
13114 {
13115 i32::try_from(v)
13116 .ok()
13117 .and_then(|x| x.try_into().ok())
13118 .ok_or_else(|| {
13119 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13120 })
13121 }
13122
13123 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13124 where
13125 E: serde::de::Error,
13126 {
13127 match value {
13128 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
13129 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
13130 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
13131 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
13132 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13133 }
13134 }
13135 }
13136 deserializer.deserialize_any(GeneratedVisitor)
13137 }
13138}
13139impl serde::Serialize for WaitRequest {
13140 #[allow(deprecated)]
13141 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13142 where
13143 S: serde::Serializer,
13144 {
13145 use serde::ser::SerializeStruct;
13146 let mut len = 0;
13147 if self.job_id.is_some() {
13148 len += 1;
13149 }
13150 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
13151 if let Some(v) = self.job_id.as_ref() {
13152 struct_ser.serialize_field("jobId", v)?;
13153 }
13154 struct_ser.end()
13155 }
13156}
13157impl<'de> serde::Deserialize<'de> for WaitRequest {
13158 #[allow(deprecated)]
13159 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13160 where
13161 D: serde::Deserializer<'de>,
13162 {
13163 const FIELDS: &[&str] = &[
13164 "job_id",
13165 "jobId",
13166 ];
13167
13168 #[allow(clippy::enum_variant_names)]
13169 enum GeneratedField {
13170 JobId,
13171 }
13172 impl<'de> serde::Deserialize<'de> for GeneratedField {
13173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13174 where
13175 D: serde::Deserializer<'de>,
13176 {
13177 struct GeneratedVisitor;
13178
13179 impl serde::de::Visitor<'_> for GeneratedVisitor {
13180 type Value = GeneratedField;
13181
13182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13183 write!(formatter, "expected one of: {:?}", &FIELDS)
13184 }
13185
13186 #[allow(unused_variables)]
13187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13188 where
13189 E: serde::de::Error,
13190 {
13191 match value {
13192 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13193 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13194 }
13195 }
13196 }
13197 deserializer.deserialize_identifier(GeneratedVisitor)
13198 }
13199 }
13200 struct GeneratedVisitor;
13201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13202 type Value = WaitRequest;
13203
13204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13205 formatter.write_str("struct ddl_service.WaitRequest")
13206 }
13207
13208 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
13209 where
13210 V: serde::de::MapAccess<'de>,
13211 {
13212 let mut job_id__ = None;
13213 while let Some(k) = map_.next_key()? {
13214 match k {
13215 GeneratedField::JobId => {
13216 if job_id__.is_some() {
13217 return Err(serde::de::Error::duplicate_field("jobId"));
13218 }
13219 job_id__ =
13220 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13221 ;
13222 }
13223 }
13224 }
13225 Ok(WaitRequest {
13226 job_id: job_id__,
13227 })
13228 }
13229 }
13230 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
13231 }
13232}
13233impl serde::Serialize for WaitResponse {
13234 #[allow(deprecated)]
13235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13236 where
13237 S: serde::Serializer,
13238 {
13239 use serde::ser::SerializeStruct;
13240 let mut len = 0;
13241 if self.version.is_some() {
13242 len += 1;
13243 }
13244 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
13245 if let Some(v) = self.version.as_ref() {
13246 struct_ser.serialize_field("version", v)?;
13247 }
13248 struct_ser.end()
13249 }
13250}
13251impl<'de> serde::Deserialize<'de> for WaitResponse {
13252 #[allow(deprecated)]
13253 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13254 where
13255 D: serde::Deserializer<'de>,
13256 {
13257 const FIELDS: &[&str] = &[
13258 "version",
13259 ];
13260
13261 #[allow(clippy::enum_variant_names)]
13262 enum GeneratedField {
13263 Version,
13264 }
13265 impl<'de> serde::Deserialize<'de> for GeneratedField {
13266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13267 where
13268 D: serde::Deserializer<'de>,
13269 {
13270 struct GeneratedVisitor;
13271
13272 impl serde::de::Visitor<'_> for GeneratedVisitor {
13273 type Value = GeneratedField;
13274
13275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13276 write!(formatter, "expected one of: {:?}", &FIELDS)
13277 }
13278
13279 #[allow(unused_variables)]
13280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13281 where
13282 E: serde::de::Error,
13283 {
13284 match value {
13285 "version" => Ok(GeneratedField::Version),
13286 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13287 }
13288 }
13289 }
13290 deserializer.deserialize_identifier(GeneratedVisitor)
13291 }
13292 }
13293 struct GeneratedVisitor;
13294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13295 type Value = WaitResponse;
13296
13297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13298 formatter.write_str("struct ddl_service.WaitResponse")
13299 }
13300
13301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
13302 where
13303 V: serde::de::MapAccess<'de>,
13304 {
13305 let mut version__ = None;
13306 while let Some(k) = map_.next_key()? {
13307 match k {
13308 GeneratedField::Version => {
13309 if version__.is_some() {
13310 return Err(serde::de::Error::duplicate_field("version"));
13311 }
13312 version__ = map_.next_value()?;
13313 }
13314 }
13315 }
13316 Ok(WaitResponse {
13317 version: version__,
13318 })
13319 }
13320 }
13321 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
13322 }
13323}
13324impl serde::Serialize for WaitVersion {
13325 #[allow(deprecated)]
13326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13327 where
13328 S: serde::Serializer,
13329 {
13330 use serde::ser::SerializeStruct;
13331 let mut len = 0;
13332 if self.catalog_version != 0 {
13333 len += 1;
13334 }
13335 if self.hummock_version_id != 0 {
13336 len += 1;
13337 }
13338 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
13339 if self.catalog_version != 0 {
13340 #[allow(clippy::needless_borrow)]
13341 #[allow(clippy::needless_borrows_for_generic_args)]
13342 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13343 }
13344 if self.hummock_version_id != 0 {
13345 #[allow(clippy::needless_borrow)]
13346 #[allow(clippy::needless_borrows_for_generic_args)]
13347 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
13348 }
13349 struct_ser.end()
13350 }
13351}
13352impl<'de> serde::Deserialize<'de> for WaitVersion {
13353 #[allow(deprecated)]
13354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13355 where
13356 D: serde::Deserializer<'de>,
13357 {
13358 const FIELDS: &[&str] = &[
13359 "catalog_version",
13360 "catalogVersion",
13361 "hummock_version_id",
13362 "hummockVersionId",
13363 ];
13364
13365 #[allow(clippy::enum_variant_names)]
13366 enum GeneratedField {
13367 CatalogVersion,
13368 HummockVersionId,
13369 }
13370 impl<'de> serde::Deserialize<'de> for GeneratedField {
13371 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13372 where
13373 D: serde::Deserializer<'de>,
13374 {
13375 struct GeneratedVisitor;
13376
13377 impl serde::de::Visitor<'_> for GeneratedVisitor {
13378 type Value = GeneratedField;
13379
13380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13381 write!(formatter, "expected one of: {:?}", &FIELDS)
13382 }
13383
13384 #[allow(unused_variables)]
13385 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13386 where
13387 E: serde::de::Error,
13388 {
13389 match value {
13390 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13391 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
13392 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13393 }
13394 }
13395 }
13396 deserializer.deserialize_identifier(GeneratedVisitor)
13397 }
13398 }
13399 struct GeneratedVisitor;
13400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13401 type Value = WaitVersion;
13402
13403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13404 formatter.write_str("struct ddl_service.WaitVersion")
13405 }
13406
13407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
13408 where
13409 V: serde::de::MapAccess<'de>,
13410 {
13411 let mut catalog_version__ = None;
13412 let mut hummock_version_id__ = None;
13413 while let Some(k) = map_.next_key()? {
13414 match k {
13415 GeneratedField::CatalogVersion => {
13416 if catalog_version__.is_some() {
13417 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13418 }
13419 catalog_version__ =
13420 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13421 ;
13422 }
13423 GeneratedField::HummockVersionId => {
13424 if hummock_version_id__.is_some() {
13425 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
13426 }
13427 hummock_version_id__ =
13428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13429 ;
13430 }
13431 }
13432 }
13433 Ok(WaitVersion {
13434 catalog_version: catalog_version__.unwrap_or_default(),
13435 hummock_version_id: hummock_version_id__.unwrap_or_default(),
13436 })
13437 }
13438 }
13439 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
13440 }
13441}