1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::ddl_service::*;
4impl serde::Serialize for AlterBackfillParallelismRequest {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if self.table_id != 0 {
13 len += 1;
14 }
15 if self.parallelism.is_some() {
16 len += 1;
17 }
18 if self.deferred {
19 len += 1;
20 }
21 if self.adaptive_parallelism_strategy.is_some() {
22 len += 1;
23 }
24 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismRequest", len)?;
25 if self.table_id != 0 {
26 struct_ser.serialize_field("tableId", &self.table_id)?;
27 }
28 if let Some(v) = self.parallelism.as_ref() {
29 struct_ser.serialize_field("parallelism", v)?;
30 }
31 if self.deferred {
32 struct_ser.serialize_field("deferred", &self.deferred)?;
33 }
34 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
35 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
36 }
37 struct_ser.end()
38 }
39}
40impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismRequest {
41 #[allow(deprecated)]
42 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
43 where
44 D: serde::Deserializer<'de>,
45 {
46 const FIELDS: &[&str] = &[
47 "table_id",
48 "tableId",
49 "parallelism",
50 "deferred",
51 "adaptive_parallelism_strategy",
52 "adaptiveParallelismStrategy",
53 ];
54
55 #[allow(clippy::enum_variant_names)]
56 enum GeneratedField {
57 TableId,
58 Parallelism,
59 Deferred,
60 AdaptiveParallelismStrategy,
61 }
62 impl<'de> serde::Deserialize<'de> for GeneratedField {
63 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
64 where
65 D: serde::Deserializer<'de>,
66 {
67 struct GeneratedVisitor;
68
69 impl serde::de::Visitor<'_> for GeneratedVisitor {
70 type Value = GeneratedField;
71
72 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
73 write!(formatter, "expected one of: {:?}", &FIELDS)
74 }
75
76 #[allow(unused_variables)]
77 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
78 where
79 E: serde::de::Error,
80 {
81 match value {
82 "tableId" | "table_id" => Ok(GeneratedField::TableId),
83 "parallelism" => Ok(GeneratedField::Parallelism),
84 "deferred" => Ok(GeneratedField::Deferred),
85 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
86 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
87 }
88 }
89 }
90 deserializer.deserialize_identifier(GeneratedVisitor)
91 }
92 }
93 struct GeneratedVisitor;
94 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
95 type Value = AlterBackfillParallelismRequest;
96
97 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
98 formatter.write_str("struct ddl_service.AlterBackfillParallelismRequest")
99 }
100
101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismRequest, V::Error>
102 where
103 V: serde::de::MapAccess<'de>,
104 {
105 let mut table_id__ = None;
106 let mut parallelism__ = None;
107 let mut deferred__ = None;
108 let mut adaptive_parallelism_strategy__ = None;
109 while let Some(k) = map_.next_key()? {
110 match k {
111 GeneratedField::TableId => {
112 if table_id__.is_some() {
113 return Err(serde::de::Error::duplicate_field("tableId"));
114 }
115 table_id__ =
116 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
117 ;
118 }
119 GeneratedField::Parallelism => {
120 if parallelism__.is_some() {
121 return Err(serde::de::Error::duplicate_field("parallelism"));
122 }
123 parallelism__ = map_.next_value()?;
124 }
125 GeneratedField::Deferred => {
126 if deferred__.is_some() {
127 return Err(serde::de::Error::duplicate_field("deferred"));
128 }
129 deferred__ = Some(map_.next_value()?);
130 }
131 GeneratedField::AdaptiveParallelismStrategy => {
132 if adaptive_parallelism_strategy__.is_some() {
133 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
134 }
135 adaptive_parallelism_strategy__ = map_.next_value()?;
136 }
137 }
138 }
139 Ok(AlterBackfillParallelismRequest {
140 table_id: table_id__.unwrap_or_default(),
141 parallelism: parallelism__,
142 deferred: deferred__.unwrap_or_default(),
143 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
144 })
145 }
146 }
147 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismRequest", FIELDS, GeneratedVisitor)
148 }
149}
150impl serde::Serialize for AlterBackfillParallelismResponse {
151 #[allow(deprecated)]
152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
153 where
154 S: serde::Serializer,
155 {
156 use serde::ser::SerializeStruct;
157 let len = 0;
158 let struct_ser = serializer.serialize_struct("ddl_service.AlterBackfillParallelismResponse", len)?;
159 struct_ser.end()
160 }
161}
162impl<'de> serde::Deserialize<'de> for AlterBackfillParallelismResponse {
163 #[allow(deprecated)]
164 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
165 where
166 D: serde::Deserializer<'de>,
167 {
168 const FIELDS: &[&str] = &[
169 ];
170
171 #[allow(clippy::enum_variant_names)]
172 enum GeneratedField {
173 }
174 impl<'de> serde::Deserialize<'de> for GeneratedField {
175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
176 where
177 D: serde::Deserializer<'de>,
178 {
179 struct GeneratedVisitor;
180
181 impl serde::de::Visitor<'_> for GeneratedVisitor {
182 type Value = GeneratedField;
183
184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
185 write!(formatter, "expected one of: {:?}", &FIELDS)
186 }
187
188 #[allow(unused_variables)]
189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
190 where
191 E: serde::de::Error,
192 {
193 Err(serde::de::Error::unknown_field(value, FIELDS))
194 }
195 }
196 deserializer.deserialize_identifier(GeneratedVisitor)
197 }
198 }
199 struct GeneratedVisitor;
200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
201 type Value = AlterBackfillParallelismResponse;
202
203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
204 formatter.write_str("struct ddl_service.AlterBackfillParallelismResponse")
205 }
206
207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterBackfillParallelismResponse, V::Error>
208 where
209 V: serde::de::MapAccess<'de>,
210 {
211 while map_.next_key::<GeneratedField>()?.is_some() {
212 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
213 }
214 Ok(AlterBackfillParallelismResponse {
215 })
216 }
217 }
218 deserializer.deserialize_struct("ddl_service.AlterBackfillParallelismResponse", FIELDS, GeneratedVisitor)
219 }
220}
221impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
222 #[allow(deprecated)]
223 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
224 where
225 S: serde::Serializer,
226 {
227 use serde::ser::SerializeStruct;
228 let mut len = 0;
229 if self.table_id != 0 {
230 len += 1;
231 }
232 if self.parallelism.is_some() {
233 len += 1;
234 }
235 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
236 if self.table_id != 0 {
237 struct_ser.serialize_field("tableId", &self.table_id)?;
238 }
239 if let Some(v) = self.parallelism.as_ref() {
240 struct_ser.serialize_field("parallelism", v)?;
241 }
242 struct_ser.end()
243 }
244}
245impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
246 #[allow(deprecated)]
247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
248 where
249 D: serde::Deserializer<'de>,
250 {
251 const FIELDS: &[&str] = &[
252 "table_id",
253 "tableId",
254 "parallelism",
255 ];
256
257 #[allow(clippy::enum_variant_names)]
258 enum GeneratedField {
259 TableId,
260 Parallelism,
261 }
262 impl<'de> serde::Deserialize<'de> for GeneratedField {
263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
264 where
265 D: serde::Deserializer<'de>,
266 {
267 struct GeneratedVisitor;
268
269 impl serde::de::Visitor<'_> for GeneratedVisitor {
270 type Value = GeneratedField;
271
272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
273 write!(formatter, "expected one of: {:?}", &FIELDS)
274 }
275
276 #[allow(unused_variables)]
277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
278 where
279 E: serde::de::Error,
280 {
281 match value {
282 "tableId" | "table_id" => Ok(GeneratedField::TableId),
283 "parallelism" => Ok(GeneratedField::Parallelism),
284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
285 }
286 }
287 }
288 deserializer.deserialize_identifier(GeneratedVisitor)
289 }
290 }
291 struct GeneratedVisitor;
292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
293 type Value = AlterCdcTableBackfillParallelismRequest;
294
295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
296 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
297 }
298
299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
300 where
301 V: serde::de::MapAccess<'de>,
302 {
303 let mut table_id__ = None;
304 let mut parallelism__ = None;
305 while let Some(k) = map_.next_key()? {
306 match k {
307 GeneratedField::TableId => {
308 if table_id__.is_some() {
309 return Err(serde::de::Error::duplicate_field("tableId"));
310 }
311 table_id__ =
312 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
313 ;
314 }
315 GeneratedField::Parallelism => {
316 if parallelism__.is_some() {
317 return Err(serde::de::Error::duplicate_field("parallelism"));
318 }
319 parallelism__ = map_.next_value()?;
320 }
321 }
322 }
323 Ok(AlterCdcTableBackfillParallelismRequest {
324 table_id: table_id__.unwrap_or_default(),
325 parallelism: parallelism__,
326 })
327 }
328 }
329 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
330 }
331}
332impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
333 #[allow(deprecated)]
334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
335 where
336 S: serde::Serializer,
337 {
338 use serde::ser::SerializeStruct;
339 let len = 0;
340 let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
341 struct_ser.end()
342 }
343}
344impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
345 #[allow(deprecated)]
346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
347 where
348 D: serde::Deserializer<'de>,
349 {
350 const FIELDS: &[&str] = &[
351 ];
352
353 #[allow(clippy::enum_variant_names)]
354 enum GeneratedField {
355 }
356 impl<'de> serde::Deserialize<'de> for GeneratedField {
357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
358 where
359 D: serde::Deserializer<'de>,
360 {
361 struct GeneratedVisitor;
362
363 impl serde::de::Visitor<'_> for GeneratedVisitor {
364 type Value = GeneratedField;
365
366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
367 write!(formatter, "expected one of: {:?}", &FIELDS)
368 }
369
370 #[allow(unused_variables)]
371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
372 where
373 E: serde::de::Error,
374 {
375 Err(serde::de::Error::unknown_field(value, FIELDS))
376 }
377 }
378 deserializer.deserialize_identifier(GeneratedVisitor)
379 }
380 }
381 struct GeneratedVisitor;
382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
383 type Value = AlterCdcTableBackfillParallelismResponse;
384
385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
386 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
387 }
388
389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
390 where
391 V: serde::de::MapAccess<'de>,
392 {
393 while map_.next_key::<GeneratedField>()?.is_some() {
394 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
395 }
396 Ok(AlterCdcTableBackfillParallelismResponse {
397 })
398 }
399 }
400 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
401 }
402}
403impl serde::Serialize for AlterDatabaseParamRequest {
404 #[allow(deprecated)]
405 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
406 where
407 S: serde::Serializer,
408 {
409 use serde::ser::SerializeStruct;
410 let mut len = 0;
411 if self.database_id != 0 {
412 len += 1;
413 }
414 if self.param.is_some() {
415 len += 1;
416 }
417 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
418 if self.database_id != 0 {
419 struct_ser.serialize_field("databaseId", &self.database_id)?;
420 }
421 if let Some(v) = self.param.as_ref() {
422 match v {
423 alter_database_param_request::Param::BarrierIntervalMs(v) => {
424 struct_ser.serialize_field("barrierIntervalMs", v)?;
425 }
426 alter_database_param_request::Param::CheckpointFrequency(v) => {
427 struct_ser.serialize_field("checkpointFrequency", v)?;
428 }
429 }
430 }
431 struct_ser.end()
432 }
433}
434impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
435 #[allow(deprecated)]
436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
437 where
438 D: serde::Deserializer<'de>,
439 {
440 const FIELDS: &[&str] = &[
441 "database_id",
442 "databaseId",
443 "barrier_interval_ms",
444 "barrierIntervalMs",
445 "checkpoint_frequency",
446 "checkpointFrequency",
447 ];
448
449 #[allow(clippy::enum_variant_names)]
450 enum GeneratedField {
451 DatabaseId,
452 BarrierIntervalMs,
453 CheckpointFrequency,
454 }
455 impl<'de> serde::Deserialize<'de> for GeneratedField {
456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
457 where
458 D: serde::Deserializer<'de>,
459 {
460 struct GeneratedVisitor;
461
462 impl serde::de::Visitor<'_> for GeneratedVisitor {
463 type Value = GeneratedField;
464
465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
466 write!(formatter, "expected one of: {:?}", &FIELDS)
467 }
468
469 #[allow(unused_variables)]
470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
471 where
472 E: serde::de::Error,
473 {
474 match value {
475 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
476 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
477 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
478 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
479 }
480 }
481 }
482 deserializer.deserialize_identifier(GeneratedVisitor)
483 }
484 }
485 struct GeneratedVisitor;
486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
487 type Value = AlterDatabaseParamRequest;
488
489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
490 formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
491 }
492
493 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
494 where
495 V: serde::de::MapAccess<'de>,
496 {
497 let mut database_id__ = None;
498 let mut param__ = None;
499 while let Some(k) = map_.next_key()? {
500 match k {
501 GeneratedField::DatabaseId => {
502 if database_id__.is_some() {
503 return Err(serde::de::Error::duplicate_field("databaseId"));
504 }
505 database_id__ =
506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
507 ;
508 }
509 GeneratedField::BarrierIntervalMs => {
510 if param__.is_some() {
511 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
512 }
513 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
514;
515 }
516 GeneratedField::CheckpointFrequency => {
517 if param__.is_some() {
518 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
519 }
520 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
521;
522 }
523 }
524 }
525 Ok(AlterDatabaseParamRequest {
526 database_id: database_id__.unwrap_or_default(),
527 param: param__,
528 })
529 }
530 }
531 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
532 }
533}
534impl serde::Serialize for AlterDatabaseParamResponse {
535 #[allow(deprecated)]
536 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
537 where
538 S: serde::Serializer,
539 {
540 use serde::ser::SerializeStruct;
541 let mut len = 0;
542 if self.status.is_some() {
543 len += 1;
544 }
545 if self.version.is_some() {
546 len += 1;
547 }
548 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
549 if let Some(v) = self.status.as_ref() {
550 struct_ser.serialize_field("status", v)?;
551 }
552 if let Some(v) = self.version.as_ref() {
553 struct_ser.serialize_field("version", v)?;
554 }
555 struct_ser.end()
556 }
557}
558impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
559 #[allow(deprecated)]
560 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
561 where
562 D: serde::Deserializer<'de>,
563 {
564 const FIELDS: &[&str] = &[
565 "status",
566 "version",
567 ];
568
569 #[allow(clippy::enum_variant_names)]
570 enum GeneratedField {
571 Status,
572 Version,
573 }
574 impl<'de> serde::Deserialize<'de> for GeneratedField {
575 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
576 where
577 D: serde::Deserializer<'de>,
578 {
579 struct GeneratedVisitor;
580
581 impl serde::de::Visitor<'_> for GeneratedVisitor {
582 type Value = GeneratedField;
583
584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
585 write!(formatter, "expected one of: {:?}", &FIELDS)
586 }
587
588 #[allow(unused_variables)]
589 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
590 where
591 E: serde::de::Error,
592 {
593 match value {
594 "status" => Ok(GeneratedField::Status),
595 "version" => Ok(GeneratedField::Version),
596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
597 }
598 }
599 }
600 deserializer.deserialize_identifier(GeneratedVisitor)
601 }
602 }
603 struct GeneratedVisitor;
604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
605 type Value = AlterDatabaseParamResponse;
606
607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
608 formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
609 }
610
611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
612 where
613 V: serde::de::MapAccess<'de>,
614 {
615 let mut status__ = None;
616 let mut version__ = None;
617 while let Some(k) = map_.next_key()? {
618 match k {
619 GeneratedField::Status => {
620 if status__.is_some() {
621 return Err(serde::de::Error::duplicate_field("status"));
622 }
623 status__ = map_.next_value()?;
624 }
625 GeneratedField::Version => {
626 if version__.is_some() {
627 return Err(serde::de::Error::duplicate_field("version"));
628 }
629 version__ = map_.next_value()?;
630 }
631 }
632 }
633 Ok(AlterDatabaseParamResponse {
634 status: status__,
635 version: version__,
636 })
637 }
638 }
639 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
640 }
641}
642impl serde::Serialize for AlterDatabaseResourceGroupRequest {
643 #[allow(deprecated)]
644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
645 where
646 S: serde::Serializer,
647 {
648 use serde::ser::SerializeStruct;
649 let mut len = 0;
650 if self.database_id != 0 {
651 len += 1;
652 }
653 if self.resource_group.is_some() {
654 len += 1;
655 }
656 if self.deferred {
657 len += 1;
658 }
659 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseResourceGroupRequest", len)?;
660 if self.database_id != 0 {
661 struct_ser.serialize_field("databaseId", &self.database_id)?;
662 }
663 if let Some(v) = self.resource_group.as_ref() {
664 struct_ser.serialize_field("resourceGroup", v)?;
665 }
666 if self.deferred {
667 struct_ser.serialize_field("deferred", &self.deferred)?;
668 }
669 struct_ser.end()
670 }
671}
672impl<'de> serde::Deserialize<'de> for AlterDatabaseResourceGroupRequest {
673 #[allow(deprecated)]
674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
675 where
676 D: serde::Deserializer<'de>,
677 {
678 const FIELDS: &[&str] = &[
679 "database_id",
680 "databaseId",
681 "resource_group",
682 "resourceGroup",
683 "deferred",
684 ];
685
686 #[allow(clippy::enum_variant_names)]
687 enum GeneratedField {
688 DatabaseId,
689 ResourceGroup,
690 Deferred,
691 }
692 impl<'de> serde::Deserialize<'de> for GeneratedField {
693 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
694 where
695 D: serde::Deserializer<'de>,
696 {
697 struct GeneratedVisitor;
698
699 impl serde::de::Visitor<'_> for GeneratedVisitor {
700 type Value = GeneratedField;
701
702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
703 write!(formatter, "expected one of: {:?}", &FIELDS)
704 }
705
706 #[allow(unused_variables)]
707 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
708 where
709 E: serde::de::Error,
710 {
711 match value {
712 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
713 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
714 "deferred" => Ok(GeneratedField::Deferred),
715 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
716 }
717 }
718 }
719 deserializer.deserialize_identifier(GeneratedVisitor)
720 }
721 }
722 struct GeneratedVisitor;
723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
724 type Value = AlterDatabaseResourceGroupRequest;
725
726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
727 formatter.write_str("struct ddl_service.AlterDatabaseResourceGroupRequest")
728 }
729
730 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseResourceGroupRequest, V::Error>
731 where
732 V: serde::de::MapAccess<'de>,
733 {
734 let mut database_id__ = None;
735 let mut resource_group__ = None;
736 let mut deferred__ = None;
737 while let Some(k) = map_.next_key()? {
738 match k {
739 GeneratedField::DatabaseId => {
740 if database_id__.is_some() {
741 return Err(serde::de::Error::duplicate_field("databaseId"));
742 }
743 database_id__ =
744 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
745 ;
746 }
747 GeneratedField::ResourceGroup => {
748 if resource_group__.is_some() {
749 return Err(serde::de::Error::duplicate_field("resourceGroup"));
750 }
751 resource_group__ = map_.next_value()?;
752 }
753 GeneratedField::Deferred => {
754 if deferred__.is_some() {
755 return Err(serde::de::Error::duplicate_field("deferred"));
756 }
757 deferred__ = Some(map_.next_value()?);
758 }
759 }
760 }
761 Ok(AlterDatabaseResourceGroupRequest {
762 database_id: database_id__.unwrap_or_default(),
763 resource_group: resource_group__,
764 deferred: deferred__.unwrap_or_default(),
765 })
766 }
767 }
768 deserializer.deserialize_struct("ddl_service.AlterDatabaseResourceGroupRequest", FIELDS, GeneratedVisitor)
769 }
770}
771impl serde::Serialize for AlterDatabaseResourceGroupResponse {
772 #[allow(deprecated)]
773 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
774 where
775 S: serde::Serializer,
776 {
777 use serde::ser::SerializeStruct;
778 let mut len = 0;
779 if self.status.is_some() {
780 len += 1;
781 }
782 if self.version.is_some() {
783 len += 1;
784 }
785 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseResourceGroupResponse", len)?;
786 if let Some(v) = self.status.as_ref() {
787 struct_ser.serialize_field("status", v)?;
788 }
789 if let Some(v) = self.version.as_ref() {
790 struct_ser.serialize_field("version", v)?;
791 }
792 struct_ser.end()
793 }
794}
795impl<'de> serde::Deserialize<'de> for AlterDatabaseResourceGroupResponse {
796 #[allow(deprecated)]
797 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
798 where
799 D: serde::Deserializer<'de>,
800 {
801 const FIELDS: &[&str] = &[
802 "status",
803 "version",
804 ];
805
806 #[allow(clippy::enum_variant_names)]
807 enum GeneratedField {
808 Status,
809 Version,
810 }
811 impl<'de> serde::Deserialize<'de> for GeneratedField {
812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
813 where
814 D: serde::Deserializer<'de>,
815 {
816 struct GeneratedVisitor;
817
818 impl serde::de::Visitor<'_> for GeneratedVisitor {
819 type Value = GeneratedField;
820
821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
822 write!(formatter, "expected one of: {:?}", &FIELDS)
823 }
824
825 #[allow(unused_variables)]
826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
827 where
828 E: serde::de::Error,
829 {
830 match value {
831 "status" => Ok(GeneratedField::Status),
832 "version" => Ok(GeneratedField::Version),
833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
834 }
835 }
836 }
837 deserializer.deserialize_identifier(GeneratedVisitor)
838 }
839 }
840 struct GeneratedVisitor;
841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
842 type Value = AlterDatabaseResourceGroupResponse;
843
844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
845 formatter.write_str("struct ddl_service.AlterDatabaseResourceGroupResponse")
846 }
847
848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseResourceGroupResponse, V::Error>
849 where
850 V: serde::de::MapAccess<'de>,
851 {
852 let mut status__ = None;
853 let mut version__ = None;
854 while let Some(k) = map_.next_key()? {
855 match k {
856 GeneratedField::Status => {
857 if status__.is_some() {
858 return Err(serde::de::Error::duplicate_field("status"));
859 }
860 status__ = map_.next_value()?;
861 }
862 GeneratedField::Version => {
863 if version__.is_some() {
864 return Err(serde::de::Error::duplicate_field("version"));
865 }
866 version__ = map_.next_value()?;
867 }
868 }
869 }
870 Ok(AlterDatabaseResourceGroupResponse {
871 status: status__,
872 version: version__,
873 })
874 }
875 }
876 deserializer.deserialize_struct("ddl_service.AlterDatabaseResourceGroupResponse", FIELDS, GeneratedVisitor)
877 }
878}
879impl serde::Serialize for AlterFragmentParallelismRequest {
880 #[allow(deprecated)]
881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
882 where
883 S: serde::Serializer,
884 {
885 use serde::ser::SerializeStruct;
886 let mut len = 0;
887 if !self.fragment_ids.is_empty() {
888 len += 1;
889 }
890 if self.parallelism.is_some() {
891 len += 1;
892 }
893 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismRequest", len)?;
894 if !self.fragment_ids.is_empty() {
895 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
896 }
897 if let Some(v) = self.parallelism.as_ref() {
898 struct_ser.serialize_field("parallelism", v)?;
899 }
900 struct_ser.end()
901 }
902}
903impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismRequest {
904 #[allow(deprecated)]
905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
906 where
907 D: serde::Deserializer<'de>,
908 {
909 const FIELDS: &[&str] = &[
910 "fragment_ids",
911 "fragmentIds",
912 "parallelism",
913 ];
914
915 #[allow(clippy::enum_variant_names)]
916 enum GeneratedField {
917 FragmentIds,
918 Parallelism,
919 }
920 impl<'de> serde::Deserialize<'de> for GeneratedField {
921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
922 where
923 D: serde::Deserializer<'de>,
924 {
925 struct GeneratedVisitor;
926
927 impl serde::de::Visitor<'_> for GeneratedVisitor {
928 type Value = GeneratedField;
929
930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
931 write!(formatter, "expected one of: {:?}", &FIELDS)
932 }
933
934 #[allow(unused_variables)]
935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
936 where
937 E: serde::de::Error,
938 {
939 match value {
940 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
941 "parallelism" => Ok(GeneratedField::Parallelism),
942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
943 }
944 }
945 }
946 deserializer.deserialize_identifier(GeneratedVisitor)
947 }
948 }
949 struct GeneratedVisitor;
950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
951 type Value = AlterFragmentParallelismRequest;
952
953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
954 formatter.write_str("struct ddl_service.AlterFragmentParallelismRequest")
955 }
956
957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismRequest, V::Error>
958 where
959 V: serde::de::MapAccess<'de>,
960 {
961 let mut fragment_ids__ = None;
962 let mut parallelism__ = None;
963 while let Some(k) = map_.next_key()? {
964 match k {
965 GeneratedField::FragmentIds => {
966 if fragment_ids__.is_some() {
967 return Err(serde::de::Error::duplicate_field("fragmentIds"));
968 }
969 fragment_ids__ =
970 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
971 .into_iter().map(|x| x.0).collect())
972 ;
973 }
974 GeneratedField::Parallelism => {
975 if parallelism__.is_some() {
976 return Err(serde::de::Error::duplicate_field("parallelism"));
977 }
978 parallelism__ = map_.next_value()?;
979 }
980 }
981 }
982 Ok(AlterFragmentParallelismRequest {
983 fragment_ids: fragment_ids__.unwrap_or_default(),
984 parallelism: parallelism__,
985 })
986 }
987 }
988 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismRequest", FIELDS, GeneratedVisitor)
989 }
990}
991impl serde::Serialize for AlterFragmentParallelismResponse {
992 #[allow(deprecated)]
993 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
994 where
995 S: serde::Serializer,
996 {
997 use serde::ser::SerializeStruct;
998 let len = 0;
999 let struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismResponse", len)?;
1000 struct_ser.end()
1001 }
1002}
1003impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismResponse {
1004 #[allow(deprecated)]
1005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1006 where
1007 D: serde::Deserializer<'de>,
1008 {
1009 const FIELDS: &[&str] = &[
1010 ];
1011
1012 #[allow(clippy::enum_variant_names)]
1013 enum GeneratedField {
1014 }
1015 impl<'de> serde::Deserialize<'de> for GeneratedField {
1016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1017 where
1018 D: serde::Deserializer<'de>,
1019 {
1020 struct GeneratedVisitor;
1021
1022 impl serde::de::Visitor<'_> for GeneratedVisitor {
1023 type Value = GeneratedField;
1024
1025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1026 write!(formatter, "expected one of: {:?}", &FIELDS)
1027 }
1028
1029 #[allow(unused_variables)]
1030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1031 where
1032 E: serde::de::Error,
1033 {
1034 Err(serde::de::Error::unknown_field(value, FIELDS))
1035 }
1036 }
1037 deserializer.deserialize_identifier(GeneratedVisitor)
1038 }
1039 }
1040 struct GeneratedVisitor;
1041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1042 type Value = AlterFragmentParallelismResponse;
1043
1044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1045 formatter.write_str("struct ddl_service.AlterFragmentParallelismResponse")
1046 }
1047
1048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismResponse, V::Error>
1049 where
1050 V: serde::de::MapAccess<'de>,
1051 {
1052 while map_.next_key::<GeneratedField>()?.is_some() {
1053 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1054 }
1055 Ok(AlterFragmentParallelismResponse {
1056 })
1057 }
1058 }
1059 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismResponse", FIELDS, GeneratedVisitor)
1060 }
1061}
1062impl serde::Serialize for AlterNameRequest {
1063 #[allow(deprecated)]
1064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1065 where
1066 S: serde::Serializer,
1067 {
1068 use serde::ser::SerializeStruct;
1069 let mut len = 0;
1070 if !self.new_name.is_empty() {
1071 len += 1;
1072 }
1073 if self.object.is_some() {
1074 len += 1;
1075 }
1076 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
1077 if !self.new_name.is_empty() {
1078 struct_ser.serialize_field("newName", &self.new_name)?;
1079 }
1080 if let Some(v) = self.object.as_ref() {
1081 match v {
1082 alter_name_request::Object::TableId(v) => {
1083 struct_ser.serialize_field("tableId", v)?;
1084 }
1085 alter_name_request::Object::ViewId(v) => {
1086 struct_ser.serialize_field("viewId", v)?;
1087 }
1088 alter_name_request::Object::IndexId(v) => {
1089 struct_ser.serialize_field("indexId", v)?;
1090 }
1091 alter_name_request::Object::SinkId(v) => {
1092 struct_ser.serialize_field("sinkId", v)?;
1093 }
1094 alter_name_request::Object::SourceId(v) => {
1095 struct_ser.serialize_field("sourceId", v)?;
1096 }
1097 alter_name_request::Object::SchemaId(v) => {
1098 struct_ser.serialize_field("schemaId", v)?;
1099 }
1100 alter_name_request::Object::DatabaseId(v) => {
1101 struct_ser.serialize_field("databaseId", v)?;
1102 }
1103 alter_name_request::Object::SubscriptionId(v) => {
1104 struct_ser.serialize_field("subscriptionId", v)?;
1105 }
1106 }
1107 }
1108 struct_ser.end()
1109 }
1110}
1111impl<'de> serde::Deserialize<'de> for AlterNameRequest {
1112 #[allow(deprecated)]
1113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1114 where
1115 D: serde::Deserializer<'de>,
1116 {
1117 const FIELDS: &[&str] = &[
1118 "new_name",
1119 "newName",
1120 "table_id",
1121 "tableId",
1122 "view_id",
1123 "viewId",
1124 "index_id",
1125 "indexId",
1126 "sink_id",
1127 "sinkId",
1128 "source_id",
1129 "sourceId",
1130 "schema_id",
1131 "schemaId",
1132 "database_id",
1133 "databaseId",
1134 "subscription_id",
1135 "subscriptionId",
1136 ];
1137
1138 #[allow(clippy::enum_variant_names)]
1139 enum GeneratedField {
1140 NewName,
1141 TableId,
1142 ViewId,
1143 IndexId,
1144 SinkId,
1145 SourceId,
1146 SchemaId,
1147 DatabaseId,
1148 SubscriptionId,
1149 }
1150 impl<'de> serde::Deserialize<'de> for GeneratedField {
1151 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1152 where
1153 D: serde::Deserializer<'de>,
1154 {
1155 struct GeneratedVisitor;
1156
1157 impl serde::de::Visitor<'_> for GeneratedVisitor {
1158 type Value = GeneratedField;
1159
1160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1161 write!(formatter, "expected one of: {:?}", &FIELDS)
1162 }
1163
1164 #[allow(unused_variables)]
1165 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1166 where
1167 E: serde::de::Error,
1168 {
1169 match value {
1170 "newName" | "new_name" => Ok(GeneratedField::NewName),
1171 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1172 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1173 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
1174 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1175 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1176 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1177 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1178 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1179 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1180 }
1181 }
1182 }
1183 deserializer.deserialize_identifier(GeneratedVisitor)
1184 }
1185 }
1186 struct GeneratedVisitor;
1187 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1188 type Value = AlterNameRequest;
1189
1190 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1191 formatter.write_str("struct ddl_service.AlterNameRequest")
1192 }
1193
1194 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
1195 where
1196 V: serde::de::MapAccess<'de>,
1197 {
1198 let mut new_name__ = None;
1199 let mut object__ = None;
1200 while let Some(k) = map_.next_key()? {
1201 match k {
1202 GeneratedField::NewName => {
1203 if new_name__.is_some() {
1204 return Err(serde::de::Error::duplicate_field("newName"));
1205 }
1206 new_name__ = Some(map_.next_value()?);
1207 }
1208 GeneratedField::TableId => {
1209 if object__.is_some() {
1210 return Err(serde::de::Error::duplicate_field("tableId"));
1211 }
1212 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
1213 }
1214 GeneratedField::ViewId => {
1215 if object__.is_some() {
1216 return Err(serde::de::Error::duplicate_field("viewId"));
1217 }
1218 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
1219 }
1220 GeneratedField::IndexId => {
1221 if object__.is_some() {
1222 return Err(serde::de::Error::duplicate_field("indexId"));
1223 }
1224 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
1225 }
1226 GeneratedField::SinkId => {
1227 if object__.is_some() {
1228 return Err(serde::de::Error::duplicate_field("sinkId"));
1229 }
1230 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
1231 }
1232 GeneratedField::SourceId => {
1233 if object__.is_some() {
1234 return Err(serde::de::Error::duplicate_field("sourceId"));
1235 }
1236 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
1237 }
1238 GeneratedField::SchemaId => {
1239 if object__.is_some() {
1240 return Err(serde::de::Error::duplicate_field("schemaId"));
1241 }
1242 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
1243 }
1244 GeneratedField::DatabaseId => {
1245 if object__.is_some() {
1246 return Err(serde::de::Error::duplicate_field("databaseId"));
1247 }
1248 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
1249 }
1250 GeneratedField::SubscriptionId => {
1251 if object__.is_some() {
1252 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1253 }
1254 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
1255 }
1256 }
1257 }
1258 Ok(AlterNameRequest {
1259 new_name: new_name__.unwrap_or_default(),
1260 object: object__,
1261 })
1262 }
1263 }
1264 deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
1265 }
1266}
1267impl serde::Serialize for AlterNameResponse {
1268 #[allow(deprecated)]
1269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1270 where
1271 S: serde::Serializer,
1272 {
1273 use serde::ser::SerializeStruct;
1274 let mut len = 0;
1275 if self.status.is_some() {
1276 len += 1;
1277 }
1278 if self.version.is_some() {
1279 len += 1;
1280 }
1281 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
1282 if let Some(v) = self.status.as_ref() {
1283 struct_ser.serialize_field("status", v)?;
1284 }
1285 if let Some(v) = self.version.as_ref() {
1286 struct_ser.serialize_field("version", v)?;
1287 }
1288 struct_ser.end()
1289 }
1290}
1291impl<'de> serde::Deserialize<'de> for AlterNameResponse {
1292 #[allow(deprecated)]
1293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1294 where
1295 D: serde::Deserializer<'de>,
1296 {
1297 const FIELDS: &[&str] = &[
1298 "status",
1299 "version",
1300 ];
1301
1302 #[allow(clippy::enum_variant_names)]
1303 enum GeneratedField {
1304 Status,
1305 Version,
1306 }
1307 impl<'de> serde::Deserialize<'de> for GeneratedField {
1308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1309 where
1310 D: serde::Deserializer<'de>,
1311 {
1312 struct GeneratedVisitor;
1313
1314 impl serde::de::Visitor<'_> for GeneratedVisitor {
1315 type Value = GeneratedField;
1316
1317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1318 write!(formatter, "expected one of: {:?}", &FIELDS)
1319 }
1320
1321 #[allow(unused_variables)]
1322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1323 where
1324 E: serde::de::Error,
1325 {
1326 match value {
1327 "status" => Ok(GeneratedField::Status),
1328 "version" => Ok(GeneratedField::Version),
1329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1330 }
1331 }
1332 }
1333 deserializer.deserialize_identifier(GeneratedVisitor)
1334 }
1335 }
1336 struct GeneratedVisitor;
1337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1338 type Value = AlterNameResponse;
1339
1340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1341 formatter.write_str("struct ddl_service.AlterNameResponse")
1342 }
1343
1344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
1345 where
1346 V: serde::de::MapAccess<'de>,
1347 {
1348 let mut status__ = None;
1349 let mut version__ = None;
1350 while let Some(k) = map_.next_key()? {
1351 match k {
1352 GeneratedField::Status => {
1353 if status__.is_some() {
1354 return Err(serde::de::Error::duplicate_field("status"));
1355 }
1356 status__ = map_.next_value()?;
1357 }
1358 GeneratedField::Version => {
1359 if version__.is_some() {
1360 return Err(serde::de::Error::duplicate_field("version"));
1361 }
1362 version__ = map_.next_value()?;
1363 }
1364 }
1365 }
1366 Ok(AlterNameResponse {
1367 status: status__,
1368 version: version__,
1369 })
1370 }
1371 }
1372 deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
1373 }
1374}
1375impl serde::Serialize for AlterOwnerRequest {
1376 #[allow(deprecated)]
1377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1378 where
1379 S: serde::Serializer,
1380 {
1381 use serde::ser::SerializeStruct;
1382 let mut len = 0;
1383 if self.owner_id != 0 {
1384 len += 1;
1385 }
1386 if self.object.is_some() {
1387 len += 1;
1388 }
1389 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
1390 if self.owner_id != 0 {
1391 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1392 }
1393 if let Some(v) = self.object.as_ref() {
1394 match v {
1395 alter_owner_request::Object::TableId(v) => {
1396 struct_ser.serialize_field("tableId", v)?;
1397 }
1398 alter_owner_request::Object::ViewId(v) => {
1399 struct_ser.serialize_field("viewId", v)?;
1400 }
1401 alter_owner_request::Object::SourceId(v) => {
1402 struct_ser.serialize_field("sourceId", v)?;
1403 }
1404 alter_owner_request::Object::SinkId(v) => {
1405 struct_ser.serialize_field("sinkId", v)?;
1406 }
1407 alter_owner_request::Object::SchemaId(v) => {
1408 struct_ser.serialize_field("schemaId", v)?;
1409 }
1410 alter_owner_request::Object::DatabaseId(v) => {
1411 struct_ser.serialize_field("databaseId", v)?;
1412 }
1413 alter_owner_request::Object::SubscriptionId(v) => {
1414 struct_ser.serialize_field("subscriptionId", v)?;
1415 }
1416 alter_owner_request::Object::ConnectionId(v) => {
1417 struct_ser.serialize_field("connectionId", v)?;
1418 }
1419 alter_owner_request::Object::SecretId(v) => {
1420 struct_ser.serialize_field("secretId", v)?;
1421 }
1422 alter_owner_request::Object::FunctionId(v) => {
1423 struct_ser.serialize_field("functionId", v)?;
1424 }
1425 }
1426 }
1427 struct_ser.end()
1428 }
1429}
1430impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
1431 #[allow(deprecated)]
1432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1433 where
1434 D: serde::Deserializer<'de>,
1435 {
1436 const FIELDS: &[&str] = &[
1437 "owner_id",
1438 "ownerId",
1439 "table_id",
1440 "tableId",
1441 "view_id",
1442 "viewId",
1443 "source_id",
1444 "sourceId",
1445 "sink_id",
1446 "sinkId",
1447 "schema_id",
1448 "schemaId",
1449 "database_id",
1450 "databaseId",
1451 "subscription_id",
1452 "subscriptionId",
1453 "connection_id",
1454 "connectionId",
1455 "secret_id",
1456 "secretId",
1457 "function_id",
1458 "functionId",
1459 ];
1460
1461 #[allow(clippy::enum_variant_names)]
1462 enum GeneratedField {
1463 OwnerId,
1464 TableId,
1465 ViewId,
1466 SourceId,
1467 SinkId,
1468 SchemaId,
1469 DatabaseId,
1470 SubscriptionId,
1471 ConnectionId,
1472 SecretId,
1473 FunctionId,
1474 }
1475 impl<'de> serde::Deserialize<'de> for GeneratedField {
1476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1477 where
1478 D: serde::Deserializer<'de>,
1479 {
1480 struct GeneratedVisitor;
1481
1482 impl serde::de::Visitor<'_> for GeneratedVisitor {
1483 type Value = GeneratedField;
1484
1485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1486 write!(formatter, "expected one of: {:?}", &FIELDS)
1487 }
1488
1489 #[allow(unused_variables)]
1490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1491 where
1492 E: serde::de::Error,
1493 {
1494 match value {
1495 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1496 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1497 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1498 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1499 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1500 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1501 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1502 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1503 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1504 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1505 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1507 }
1508 }
1509 }
1510 deserializer.deserialize_identifier(GeneratedVisitor)
1511 }
1512 }
1513 struct GeneratedVisitor;
1514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1515 type Value = AlterOwnerRequest;
1516
1517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1518 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1519 }
1520
1521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1522 where
1523 V: serde::de::MapAccess<'de>,
1524 {
1525 let mut owner_id__ = None;
1526 let mut object__ = None;
1527 while let Some(k) = map_.next_key()? {
1528 match k {
1529 GeneratedField::OwnerId => {
1530 if owner_id__.is_some() {
1531 return Err(serde::de::Error::duplicate_field("ownerId"));
1532 }
1533 owner_id__ =
1534 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1535 ;
1536 }
1537 GeneratedField::TableId => {
1538 if object__.is_some() {
1539 return Err(serde::de::Error::duplicate_field("tableId"));
1540 }
1541 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1542 }
1543 GeneratedField::ViewId => {
1544 if object__.is_some() {
1545 return Err(serde::de::Error::duplicate_field("viewId"));
1546 }
1547 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1548 }
1549 GeneratedField::SourceId => {
1550 if object__.is_some() {
1551 return Err(serde::de::Error::duplicate_field("sourceId"));
1552 }
1553 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1554 }
1555 GeneratedField::SinkId => {
1556 if object__.is_some() {
1557 return Err(serde::de::Error::duplicate_field("sinkId"));
1558 }
1559 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1560 }
1561 GeneratedField::SchemaId => {
1562 if object__.is_some() {
1563 return Err(serde::de::Error::duplicate_field("schemaId"));
1564 }
1565 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1566 }
1567 GeneratedField::DatabaseId => {
1568 if object__.is_some() {
1569 return Err(serde::de::Error::duplicate_field("databaseId"));
1570 }
1571 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1572 }
1573 GeneratedField::SubscriptionId => {
1574 if object__.is_some() {
1575 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1576 }
1577 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1578 }
1579 GeneratedField::ConnectionId => {
1580 if object__.is_some() {
1581 return Err(serde::de::Error::duplicate_field("connectionId"));
1582 }
1583 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1584 }
1585 GeneratedField::SecretId => {
1586 if object__.is_some() {
1587 return Err(serde::de::Error::duplicate_field("secretId"));
1588 }
1589 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SecretId(x.0));
1590 }
1591 GeneratedField::FunctionId => {
1592 if object__.is_some() {
1593 return Err(serde::de::Error::duplicate_field("functionId"));
1594 }
1595 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::FunctionId(x.0));
1596 }
1597 }
1598 }
1599 Ok(AlterOwnerRequest {
1600 owner_id: owner_id__.unwrap_or_default(),
1601 object: object__,
1602 })
1603 }
1604 }
1605 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1606 }
1607}
1608impl serde::Serialize for AlterOwnerResponse {
1609 #[allow(deprecated)]
1610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1611 where
1612 S: serde::Serializer,
1613 {
1614 use serde::ser::SerializeStruct;
1615 let mut len = 0;
1616 if self.status.is_some() {
1617 len += 1;
1618 }
1619 if self.version.is_some() {
1620 len += 1;
1621 }
1622 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1623 if let Some(v) = self.status.as_ref() {
1624 struct_ser.serialize_field("status", v)?;
1625 }
1626 if let Some(v) = self.version.as_ref() {
1627 struct_ser.serialize_field("version", v)?;
1628 }
1629 struct_ser.end()
1630 }
1631}
1632impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1633 #[allow(deprecated)]
1634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1635 where
1636 D: serde::Deserializer<'de>,
1637 {
1638 const FIELDS: &[&str] = &[
1639 "status",
1640 "version",
1641 ];
1642
1643 #[allow(clippy::enum_variant_names)]
1644 enum GeneratedField {
1645 Status,
1646 Version,
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 match value {
1668 "status" => Ok(GeneratedField::Status),
1669 "version" => Ok(GeneratedField::Version),
1670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1671 }
1672 }
1673 }
1674 deserializer.deserialize_identifier(GeneratedVisitor)
1675 }
1676 }
1677 struct GeneratedVisitor;
1678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1679 type Value = AlterOwnerResponse;
1680
1681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1682 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1683 }
1684
1685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1686 where
1687 V: serde::de::MapAccess<'de>,
1688 {
1689 let mut status__ = None;
1690 let mut version__ = None;
1691 while let Some(k) = map_.next_key()? {
1692 match k {
1693 GeneratedField::Status => {
1694 if status__.is_some() {
1695 return Err(serde::de::Error::duplicate_field("status"));
1696 }
1697 status__ = map_.next_value()?;
1698 }
1699 GeneratedField::Version => {
1700 if version__.is_some() {
1701 return Err(serde::de::Error::duplicate_field("version"));
1702 }
1703 version__ = map_.next_value()?;
1704 }
1705 }
1706 }
1707 Ok(AlterOwnerResponse {
1708 status: status__,
1709 version: version__,
1710 })
1711 }
1712 }
1713 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1714 }
1715}
1716impl serde::Serialize for AlterParallelismRequest {
1717 #[allow(deprecated)]
1718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1719 where
1720 S: serde::Serializer,
1721 {
1722 use serde::ser::SerializeStruct;
1723 let mut len = 0;
1724 if self.table_id != 0 {
1725 len += 1;
1726 }
1727 if self.parallelism.is_some() {
1728 len += 1;
1729 }
1730 if self.deferred {
1731 len += 1;
1732 }
1733 if self.adaptive_parallelism_strategy.is_some() {
1734 len += 1;
1735 }
1736 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1737 if self.table_id != 0 {
1738 struct_ser.serialize_field("tableId", &self.table_id)?;
1739 }
1740 if let Some(v) = self.parallelism.as_ref() {
1741 struct_ser.serialize_field("parallelism", v)?;
1742 }
1743 if self.deferred {
1744 struct_ser.serialize_field("deferred", &self.deferred)?;
1745 }
1746 if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
1747 struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
1748 }
1749 struct_ser.end()
1750 }
1751}
1752impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1753 #[allow(deprecated)]
1754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1755 where
1756 D: serde::Deserializer<'de>,
1757 {
1758 const FIELDS: &[&str] = &[
1759 "table_id",
1760 "tableId",
1761 "parallelism",
1762 "deferred",
1763 "adaptive_parallelism_strategy",
1764 "adaptiveParallelismStrategy",
1765 ];
1766
1767 #[allow(clippy::enum_variant_names)]
1768 enum GeneratedField {
1769 TableId,
1770 Parallelism,
1771 Deferred,
1772 AdaptiveParallelismStrategy,
1773 }
1774 impl<'de> serde::Deserialize<'de> for GeneratedField {
1775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1776 where
1777 D: serde::Deserializer<'de>,
1778 {
1779 struct GeneratedVisitor;
1780
1781 impl serde::de::Visitor<'_> for GeneratedVisitor {
1782 type Value = GeneratedField;
1783
1784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1785 write!(formatter, "expected one of: {:?}", &FIELDS)
1786 }
1787
1788 #[allow(unused_variables)]
1789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1790 where
1791 E: serde::de::Error,
1792 {
1793 match value {
1794 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1795 "parallelism" => Ok(GeneratedField::Parallelism),
1796 "deferred" => Ok(GeneratedField::Deferred),
1797 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
1798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1799 }
1800 }
1801 }
1802 deserializer.deserialize_identifier(GeneratedVisitor)
1803 }
1804 }
1805 struct GeneratedVisitor;
1806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1807 type Value = AlterParallelismRequest;
1808
1809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1810 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1811 }
1812
1813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1814 where
1815 V: serde::de::MapAccess<'de>,
1816 {
1817 let mut table_id__ = None;
1818 let mut parallelism__ = None;
1819 let mut deferred__ = None;
1820 let mut adaptive_parallelism_strategy__ = None;
1821 while let Some(k) = map_.next_key()? {
1822 match k {
1823 GeneratedField::TableId => {
1824 if table_id__.is_some() {
1825 return Err(serde::de::Error::duplicate_field("tableId"));
1826 }
1827 table_id__ =
1828 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1829 ;
1830 }
1831 GeneratedField::Parallelism => {
1832 if parallelism__.is_some() {
1833 return Err(serde::de::Error::duplicate_field("parallelism"));
1834 }
1835 parallelism__ = map_.next_value()?;
1836 }
1837 GeneratedField::Deferred => {
1838 if deferred__.is_some() {
1839 return Err(serde::de::Error::duplicate_field("deferred"));
1840 }
1841 deferred__ = Some(map_.next_value()?);
1842 }
1843 GeneratedField::AdaptiveParallelismStrategy => {
1844 if adaptive_parallelism_strategy__.is_some() {
1845 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
1846 }
1847 adaptive_parallelism_strategy__ = map_.next_value()?;
1848 }
1849 }
1850 }
1851 Ok(AlterParallelismRequest {
1852 table_id: table_id__.unwrap_or_default(),
1853 parallelism: parallelism__,
1854 deferred: deferred__.unwrap_or_default(),
1855 adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
1856 })
1857 }
1858 }
1859 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1860 }
1861}
1862impl serde::Serialize for AlterParallelismResponse {
1863 #[allow(deprecated)]
1864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1865 where
1866 S: serde::Serializer,
1867 {
1868 use serde::ser::SerializeStruct;
1869 let len = 0;
1870 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1871 struct_ser.end()
1872 }
1873}
1874impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1875 #[allow(deprecated)]
1876 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1877 where
1878 D: serde::Deserializer<'de>,
1879 {
1880 const FIELDS: &[&str] = &[
1881 ];
1882
1883 #[allow(clippy::enum_variant_names)]
1884 enum GeneratedField {
1885 }
1886 impl<'de> serde::Deserialize<'de> for GeneratedField {
1887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1888 where
1889 D: serde::Deserializer<'de>,
1890 {
1891 struct GeneratedVisitor;
1892
1893 impl serde::de::Visitor<'_> for GeneratedVisitor {
1894 type Value = GeneratedField;
1895
1896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1897 write!(formatter, "expected one of: {:?}", &FIELDS)
1898 }
1899
1900 #[allow(unused_variables)]
1901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1902 where
1903 E: serde::de::Error,
1904 {
1905 Err(serde::de::Error::unknown_field(value, FIELDS))
1906 }
1907 }
1908 deserializer.deserialize_identifier(GeneratedVisitor)
1909 }
1910 }
1911 struct GeneratedVisitor;
1912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1913 type Value = AlterParallelismResponse;
1914
1915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1916 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1917 }
1918
1919 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1920 where
1921 V: serde::de::MapAccess<'de>,
1922 {
1923 while map_.next_key::<GeneratedField>()?.is_some() {
1924 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1925 }
1926 Ok(AlterParallelismResponse {
1927 })
1928 }
1929 }
1930 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1931 }
1932}
1933impl serde::Serialize for AlterResourceGroupRequest {
1934 #[allow(deprecated)]
1935 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1936 where
1937 S: serde::Serializer,
1938 {
1939 use serde::ser::SerializeStruct;
1940 let mut len = 0;
1941 if self.job_id != 0 {
1942 len += 1;
1943 }
1944 if self.resource_group.is_some() {
1945 len += 1;
1946 }
1947 if self.deferred {
1948 len += 1;
1949 }
1950 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1951 if self.job_id != 0 {
1952 struct_ser.serialize_field("jobId", &self.job_id)?;
1953 }
1954 if let Some(v) = self.resource_group.as_ref() {
1955 struct_ser.serialize_field("resourceGroup", v)?;
1956 }
1957 if self.deferred {
1958 struct_ser.serialize_field("deferred", &self.deferred)?;
1959 }
1960 struct_ser.end()
1961 }
1962}
1963impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1964 #[allow(deprecated)]
1965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1966 where
1967 D: serde::Deserializer<'de>,
1968 {
1969 const FIELDS: &[&str] = &[
1970 "job_id",
1971 "jobId",
1972 "resource_group",
1973 "resourceGroup",
1974 "deferred",
1975 ];
1976
1977 #[allow(clippy::enum_variant_names)]
1978 enum GeneratedField {
1979 JobId,
1980 ResourceGroup,
1981 Deferred,
1982 }
1983 impl<'de> serde::Deserialize<'de> for GeneratedField {
1984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1985 where
1986 D: serde::Deserializer<'de>,
1987 {
1988 struct GeneratedVisitor;
1989
1990 impl serde::de::Visitor<'_> for GeneratedVisitor {
1991 type Value = GeneratedField;
1992
1993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1994 write!(formatter, "expected one of: {:?}", &FIELDS)
1995 }
1996
1997 #[allow(unused_variables)]
1998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1999 where
2000 E: serde::de::Error,
2001 {
2002 match value {
2003 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2004 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
2005 "deferred" => Ok(GeneratedField::Deferred),
2006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2007 }
2008 }
2009 }
2010 deserializer.deserialize_identifier(GeneratedVisitor)
2011 }
2012 }
2013 struct GeneratedVisitor;
2014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2015 type Value = AlterResourceGroupRequest;
2016
2017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2018 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
2019 }
2020
2021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
2022 where
2023 V: serde::de::MapAccess<'de>,
2024 {
2025 let mut job_id__ = None;
2026 let mut resource_group__ = None;
2027 let mut deferred__ = None;
2028 while let Some(k) = map_.next_key()? {
2029 match k {
2030 GeneratedField::JobId => {
2031 if job_id__.is_some() {
2032 return Err(serde::de::Error::duplicate_field("jobId"));
2033 }
2034 job_id__ =
2035 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2036 ;
2037 }
2038 GeneratedField::ResourceGroup => {
2039 if resource_group__.is_some() {
2040 return Err(serde::de::Error::duplicate_field("resourceGroup"));
2041 }
2042 resource_group__ = map_.next_value()?;
2043 }
2044 GeneratedField::Deferred => {
2045 if deferred__.is_some() {
2046 return Err(serde::de::Error::duplicate_field("deferred"));
2047 }
2048 deferred__ = Some(map_.next_value()?);
2049 }
2050 }
2051 }
2052 Ok(AlterResourceGroupRequest {
2053 job_id: job_id__.unwrap_or_default(),
2054 resource_group: resource_group__,
2055 deferred: deferred__.unwrap_or_default(),
2056 })
2057 }
2058 }
2059 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
2060 }
2061}
2062impl serde::Serialize for AlterResourceGroupResponse {
2063 #[allow(deprecated)]
2064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2065 where
2066 S: serde::Serializer,
2067 {
2068 use serde::ser::SerializeStruct;
2069 let len = 0;
2070 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
2071 struct_ser.end()
2072 }
2073}
2074impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
2075 #[allow(deprecated)]
2076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2077 where
2078 D: serde::Deserializer<'de>,
2079 {
2080 const FIELDS: &[&str] = &[
2081 ];
2082
2083 #[allow(clippy::enum_variant_names)]
2084 enum GeneratedField {
2085 }
2086 impl<'de> serde::Deserialize<'de> for GeneratedField {
2087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2088 where
2089 D: serde::Deserializer<'de>,
2090 {
2091 struct GeneratedVisitor;
2092
2093 impl serde::de::Visitor<'_> for GeneratedVisitor {
2094 type Value = GeneratedField;
2095
2096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2097 write!(formatter, "expected one of: {:?}", &FIELDS)
2098 }
2099
2100 #[allow(unused_variables)]
2101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2102 where
2103 E: serde::de::Error,
2104 {
2105 Err(serde::de::Error::unknown_field(value, FIELDS))
2106 }
2107 }
2108 deserializer.deserialize_identifier(GeneratedVisitor)
2109 }
2110 }
2111 struct GeneratedVisitor;
2112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2113 type Value = AlterResourceGroupResponse;
2114
2115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2116 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
2117 }
2118
2119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
2120 where
2121 V: serde::de::MapAccess<'de>,
2122 {
2123 while map_.next_key::<GeneratedField>()?.is_some() {
2124 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2125 }
2126 Ok(AlterResourceGroupResponse {
2127 })
2128 }
2129 }
2130 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
2131 }
2132}
2133impl serde::Serialize for AlterSecretRequest {
2134 #[allow(deprecated)]
2135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2136 where
2137 S: serde::Serializer,
2138 {
2139 use serde::ser::SerializeStruct;
2140 let mut len = 0;
2141 if self.secret_id != 0 {
2142 len += 1;
2143 }
2144 if !self.name.is_empty() {
2145 len += 1;
2146 }
2147 if !self.value.is_empty() {
2148 len += 1;
2149 }
2150 if self.database_id != 0 {
2151 len += 1;
2152 }
2153 if self.schema_id != 0 {
2154 len += 1;
2155 }
2156 if self.owner_id != 0 {
2157 len += 1;
2158 }
2159 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
2160 if self.secret_id != 0 {
2161 struct_ser.serialize_field("secretId", &self.secret_id)?;
2162 }
2163 if !self.name.is_empty() {
2164 struct_ser.serialize_field("name", &self.name)?;
2165 }
2166 if !self.value.is_empty() {
2167 #[allow(clippy::needless_borrow)]
2168 #[allow(clippy::needless_borrows_for_generic_args)]
2169 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
2170 }
2171 if self.database_id != 0 {
2172 struct_ser.serialize_field("databaseId", &self.database_id)?;
2173 }
2174 if self.schema_id != 0 {
2175 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2176 }
2177 if self.owner_id != 0 {
2178 struct_ser.serialize_field("ownerId", &self.owner_id)?;
2179 }
2180 struct_ser.end()
2181 }
2182}
2183impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
2184 #[allow(deprecated)]
2185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2186 where
2187 D: serde::Deserializer<'de>,
2188 {
2189 const FIELDS: &[&str] = &[
2190 "secret_id",
2191 "secretId",
2192 "name",
2193 "value",
2194 "database_id",
2195 "databaseId",
2196 "schema_id",
2197 "schemaId",
2198 "owner_id",
2199 "ownerId",
2200 ];
2201
2202 #[allow(clippy::enum_variant_names)]
2203 enum GeneratedField {
2204 SecretId,
2205 Name,
2206 Value,
2207 DatabaseId,
2208 SchemaId,
2209 OwnerId,
2210 }
2211 impl<'de> serde::Deserialize<'de> for GeneratedField {
2212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2213 where
2214 D: serde::Deserializer<'de>,
2215 {
2216 struct GeneratedVisitor;
2217
2218 impl serde::de::Visitor<'_> for GeneratedVisitor {
2219 type Value = GeneratedField;
2220
2221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2222 write!(formatter, "expected one of: {:?}", &FIELDS)
2223 }
2224
2225 #[allow(unused_variables)]
2226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2227 where
2228 E: serde::de::Error,
2229 {
2230 match value {
2231 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
2232 "name" => Ok(GeneratedField::Name),
2233 "value" => Ok(GeneratedField::Value),
2234 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2235 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2236 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
2237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2238 }
2239 }
2240 }
2241 deserializer.deserialize_identifier(GeneratedVisitor)
2242 }
2243 }
2244 struct GeneratedVisitor;
2245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2246 type Value = AlterSecretRequest;
2247
2248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2249 formatter.write_str("struct ddl_service.AlterSecretRequest")
2250 }
2251
2252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
2253 where
2254 V: serde::de::MapAccess<'de>,
2255 {
2256 let mut secret_id__ = None;
2257 let mut name__ = None;
2258 let mut value__ = None;
2259 let mut database_id__ = None;
2260 let mut schema_id__ = None;
2261 let mut owner_id__ = None;
2262 while let Some(k) = map_.next_key()? {
2263 match k {
2264 GeneratedField::SecretId => {
2265 if secret_id__.is_some() {
2266 return Err(serde::de::Error::duplicate_field("secretId"));
2267 }
2268 secret_id__ =
2269 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2270 ;
2271 }
2272 GeneratedField::Name => {
2273 if name__.is_some() {
2274 return Err(serde::de::Error::duplicate_field("name"));
2275 }
2276 name__ = Some(map_.next_value()?);
2277 }
2278 GeneratedField::Value => {
2279 if value__.is_some() {
2280 return Err(serde::de::Error::duplicate_field("value"));
2281 }
2282 value__ =
2283 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2284 ;
2285 }
2286 GeneratedField::DatabaseId => {
2287 if database_id__.is_some() {
2288 return Err(serde::de::Error::duplicate_field("databaseId"));
2289 }
2290 database_id__ =
2291 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2292 ;
2293 }
2294 GeneratedField::SchemaId => {
2295 if schema_id__.is_some() {
2296 return Err(serde::de::Error::duplicate_field("schemaId"));
2297 }
2298 schema_id__ =
2299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2300 ;
2301 }
2302 GeneratedField::OwnerId => {
2303 if owner_id__.is_some() {
2304 return Err(serde::de::Error::duplicate_field("ownerId"));
2305 }
2306 owner_id__ =
2307 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2308 ;
2309 }
2310 }
2311 }
2312 Ok(AlterSecretRequest {
2313 secret_id: secret_id__.unwrap_or_default(),
2314 name: name__.unwrap_or_default(),
2315 value: value__.unwrap_or_default(),
2316 database_id: database_id__.unwrap_or_default(),
2317 schema_id: schema_id__.unwrap_or_default(),
2318 owner_id: owner_id__.unwrap_or_default(),
2319 })
2320 }
2321 }
2322 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
2323 }
2324}
2325impl serde::Serialize for AlterSecretResponse {
2326 #[allow(deprecated)]
2327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2328 where
2329 S: serde::Serializer,
2330 {
2331 use serde::ser::SerializeStruct;
2332 let mut len = 0;
2333 if self.version.is_some() {
2334 len += 1;
2335 }
2336 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
2337 if let Some(v) = self.version.as_ref() {
2338 struct_ser.serialize_field("version", v)?;
2339 }
2340 struct_ser.end()
2341 }
2342}
2343impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
2344 #[allow(deprecated)]
2345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2346 where
2347 D: serde::Deserializer<'de>,
2348 {
2349 const FIELDS: &[&str] = &[
2350 "version",
2351 ];
2352
2353 #[allow(clippy::enum_variant_names)]
2354 enum GeneratedField {
2355 Version,
2356 }
2357 impl<'de> serde::Deserialize<'de> for GeneratedField {
2358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2359 where
2360 D: serde::Deserializer<'de>,
2361 {
2362 struct GeneratedVisitor;
2363
2364 impl serde::de::Visitor<'_> for GeneratedVisitor {
2365 type Value = GeneratedField;
2366
2367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2368 write!(formatter, "expected one of: {:?}", &FIELDS)
2369 }
2370
2371 #[allow(unused_variables)]
2372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2373 where
2374 E: serde::de::Error,
2375 {
2376 match value {
2377 "version" => Ok(GeneratedField::Version),
2378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2379 }
2380 }
2381 }
2382 deserializer.deserialize_identifier(GeneratedVisitor)
2383 }
2384 }
2385 struct GeneratedVisitor;
2386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2387 type Value = AlterSecretResponse;
2388
2389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2390 formatter.write_str("struct ddl_service.AlterSecretResponse")
2391 }
2392
2393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
2394 where
2395 V: serde::de::MapAccess<'de>,
2396 {
2397 let mut version__ = None;
2398 while let Some(k) = map_.next_key()? {
2399 match k {
2400 GeneratedField::Version => {
2401 if version__.is_some() {
2402 return Err(serde::de::Error::duplicate_field("version"));
2403 }
2404 version__ = map_.next_value()?;
2405 }
2406 }
2407 }
2408 Ok(AlterSecretResponse {
2409 version: version__,
2410 })
2411 }
2412 }
2413 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
2414 }
2415}
2416impl serde::Serialize for AlterSetSchemaRequest {
2417 #[allow(deprecated)]
2418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2419 where
2420 S: serde::Serializer,
2421 {
2422 use serde::ser::SerializeStruct;
2423 let mut len = 0;
2424 if self.new_schema_id != 0 {
2425 len += 1;
2426 }
2427 if self.object.is_some() {
2428 len += 1;
2429 }
2430 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
2431 if self.new_schema_id != 0 {
2432 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
2433 }
2434 if let Some(v) = self.object.as_ref() {
2435 match v {
2436 alter_set_schema_request::Object::TableId(v) => {
2437 struct_ser.serialize_field("tableId", v)?;
2438 }
2439 alter_set_schema_request::Object::ViewId(v) => {
2440 struct_ser.serialize_field("viewId", v)?;
2441 }
2442 alter_set_schema_request::Object::SourceId(v) => {
2443 struct_ser.serialize_field("sourceId", v)?;
2444 }
2445 alter_set_schema_request::Object::SinkId(v) => {
2446 struct_ser.serialize_field("sinkId", v)?;
2447 }
2448 alter_set_schema_request::Object::FunctionId(v) => {
2449 struct_ser.serialize_field("functionId", v)?;
2450 }
2451 alter_set_schema_request::Object::ConnectionId(v) => {
2452 struct_ser.serialize_field("connectionId", v)?;
2453 }
2454 alter_set_schema_request::Object::SubscriptionId(v) => {
2455 struct_ser.serialize_field("subscriptionId", v)?;
2456 }
2457 }
2458 }
2459 struct_ser.end()
2460 }
2461}
2462impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
2463 #[allow(deprecated)]
2464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2465 where
2466 D: serde::Deserializer<'de>,
2467 {
2468 const FIELDS: &[&str] = &[
2469 "new_schema_id",
2470 "newSchemaId",
2471 "table_id",
2472 "tableId",
2473 "view_id",
2474 "viewId",
2475 "source_id",
2476 "sourceId",
2477 "sink_id",
2478 "sinkId",
2479 "function_id",
2480 "functionId",
2481 "connection_id",
2482 "connectionId",
2483 "subscription_id",
2484 "subscriptionId",
2485 ];
2486
2487 #[allow(clippy::enum_variant_names)]
2488 enum GeneratedField {
2489 NewSchemaId,
2490 TableId,
2491 ViewId,
2492 SourceId,
2493 SinkId,
2494 FunctionId,
2495 ConnectionId,
2496 SubscriptionId,
2497 }
2498 impl<'de> serde::Deserialize<'de> for GeneratedField {
2499 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2500 where
2501 D: serde::Deserializer<'de>,
2502 {
2503 struct GeneratedVisitor;
2504
2505 impl serde::de::Visitor<'_> for GeneratedVisitor {
2506 type Value = GeneratedField;
2507
2508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2509 write!(formatter, "expected one of: {:?}", &FIELDS)
2510 }
2511
2512 #[allow(unused_variables)]
2513 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2514 where
2515 E: serde::de::Error,
2516 {
2517 match value {
2518 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2519 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2520 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2521 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2522 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2523 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2524 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2525 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2526 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2527 }
2528 }
2529 }
2530 deserializer.deserialize_identifier(GeneratedVisitor)
2531 }
2532 }
2533 struct GeneratedVisitor;
2534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2535 type Value = AlterSetSchemaRequest;
2536
2537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2538 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2539 }
2540
2541 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2542 where
2543 V: serde::de::MapAccess<'de>,
2544 {
2545 let mut new_schema_id__ = None;
2546 let mut object__ = None;
2547 while let Some(k) = map_.next_key()? {
2548 match k {
2549 GeneratedField::NewSchemaId => {
2550 if new_schema_id__.is_some() {
2551 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2552 }
2553 new_schema_id__ =
2554 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2555 ;
2556 }
2557 GeneratedField::TableId => {
2558 if object__.is_some() {
2559 return Err(serde::de::Error::duplicate_field("tableId"));
2560 }
2561 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2562 }
2563 GeneratedField::ViewId => {
2564 if object__.is_some() {
2565 return Err(serde::de::Error::duplicate_field("viewId"));
2566 }
2567 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2568 }
2569 GeneratedField::SourceId => {
2570 if object__.is_some() {
2571 return Err(serde::de::Error::duplicate_field("sourceId"));
2572 }
2573 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2574 }
2575 GeneratedField::SinkId => {
2576 if object__.is_some() {
2577 return Err(serde::de::Error::duplicate_field("sinkId"));
2578 }
2579 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2580 }
2581 GeneratedField::FunctionId => {
2582 if object__.is_some() {
2583 return Err(serde::de::Error::duplicate_field("functionId"));
2584 }
2585 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2586 }
2587 GeneratedField::ConnectionId => {
2588 if object__.is_some() {
2589 return Err(serde::de::Error::duplicate_field("connectionId"));
2590 }
2591 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2592 }
2593 GeneratedField::SubscriptionId => {
2594 if object__.is_some() {
2595 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2596 }
2597 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2598 }
2599 }
2600 }
2601 Ok(AlterSetSchemaRequest {
2602 new_schema_id: new_schema_id__.unwrap_or_default(),
2603 object: object__,
2604 })
2605 }
2606 }
2607 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2608 }
2609}
2610impl serde::Serialize for AlterSetSchemaResponse {
2611 #[allow(deprecated)]
2612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2613 where
2614 S: serde::Serializer,
2615 {
2616 use serde::ser::SerializeStruct;
2617 let mut len = 0;
2618 if self.status.is_some() {
2619 len += 1;
2620 }
2621 if self.version.is_some() {
2622 len += 1;
2623 }
2624 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2625 if let Some(v) = self.status.as_ref() {
2626 struct_ser.serialize_field("status", v)?;
2627 }
2628 if let Some(v) = self.version.as_ref() {
2629 struct_ser.serialize_field("version", v)?;
2630 }
2631 struct_ser.end()
2632 }
2633}
2634impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2635 #[allow(deprecated)]
2636 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2637 where
2638 D: serde::Deserializer<'de>,
2639 {
2640 const FIELDS: &[&str] = &[
2641 "status",
2642 "version",
2643 ];
2644
2645 #[allow(clippy::enum_variant_names)]
2646 enum GeneratedField {
2647 Status,
2648 Version,
2649 }
2650 impl<'de> serde::Deserialize<'de> for GeneratedField {
2651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2652 where
2653 D: serde::Deserializer<'de>,
2654 {
2655 struct GeneratedVisitor;
2656
2657 impl serde::de::Visitor<'_> for GeneratedVisitor {
2658 type Value = GeneratedField;
2659
2660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2661 write!(formatter, "expected one of: {:?}", &FIELDS)
2662 }
2663
2664 #[allow(unused_variables)]
2665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2666 where
2667 E: serde::de::Error,
2668 {
2669 match value {
2670 "status" => Ok(GeneratedField::Status),
2671 "version" => Ok(GeneratedField::Version),
2672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2673 }
2674 }
2675 }
2676 deserializer.deserialize_identifier(GeneratedVisitor)
2677 }
2678 }
2679 struct GeneratedVisitor;
2680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2681 type Value = AlterSetSchemaResponse;
2682
2683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2684 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2685 }
2686
2687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2688 where
2689 V: serde::de::MapAccess<'de>,
2690 {
2691 let mut status__ = None;
2692 let mut version__ = None;
2693 while let Some(k) = map_.next_key()? {
2694 match k {
2695 GeneratedField::Status => {
2696 if status__.is_some() {
2697 return Err(serde::de::Error::duplicate_field("status"));
2698 }
2699 status__ = map_.next_value()?;
2700 }
2701 GeneratedField::Version => {
2702 if version__.is_some() {
2703 return Err(serde::de::Error::duplicate_field("version"));
2704 }
2705 version__ = map_.next_value()?;
2706 }
2707 }
2708 }
2709 Ok(AlterSetSchemaResponse {
2710 status: status__,
2711 version: version__,
2712 })
2713 }
2714 }
2715 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2716 }
2717}
2718impl serde::Serialize for AlterSourceRequest {
2719 #[allow(deprecated)]
2720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2721 where
2722 S: serde::Serializer,
2723 {
2724 use serde::ser::SerializeStruct;
2725 let mut len = 0;
2726 if self.source.is_some() {
2727 len += 1;
2728 }
2729 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2730 if let Some(v) = self.source.as_ref() {
2731 struct_ser.serialize_field("source", v)?;
2732 }
2733 struct_ser.end()
2734 }
2735}
2736impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2737 #[allow(deprecated)]
2738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2739 where
2740 D: serde::Deserializer<'de>,
2741 {
2742 const FIELDS: &[&str] = &[
2743 "source",
2744 ];
2745
2746 #[allow(clippy::enum_variant_names)]
2747 enum GeneratedField {
2748 Source,
2749 }
2750 impl<'de> serde::Deserialize<'de> for GeneratedField {
2751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2752 where
2753 D: serde::Deserializer<'de>,
2754 {
2755 struct GeneratedVisitor;
2756
2757 impl serde::de::Visitor<'_> for GeneratedVisitor {
2758 type Value = GeneratedField;
2759
2760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2761 write!(formatter, "expected one of: {:?}", &FIELDS)
2762 }
2763
2764 #[allow(unused_variables)]
2765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2766 where
2767 E: serde::de::Error,
2768 {
2769 match value {
2770 "source" => Ok(GeneratedField::Source),
2771 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2772 }
2773 }
2774 }
2775 deserializer.deserialize_identifier(GeneratedVisitor)
2776 }
2777 }
2778 struct GeneratedVisitor;
2779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2780 type Value = AlterSourceRequest;
2781
2782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2783 formatter.write_str("struct ddl_service.AlterSourceRequest")
2784 }
2785
2786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2787 where
2788 V: serde::de::MapAccess<'de>,
2789 {
2790 let mut source__ = None;
2791 while let Some(k) = map_.next_key()? {
2792 match k {
2793 GeneratedField::Source => {
2794 if source__.is_some() {
2795 return Err(serde::de::Error::duplicate_field("source"));
2796 }
2797 source__ = map_.next_value()?;
2798 }
2799 }
2800 }
2801 Ok(AlterSourceRequest {
2802 source: source__,
2803 })
2804 }
2805 }
2806 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2807 }
2808}
2809impl serde::Serialize for AlterSourceResponse {
2810 #[allow(deprecated)]
2811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2812 where
2813 S: serde::Serializer,
2814 {
2815 use serde::ser::SerializeStruct;
2816 let mut len = 0;
2817 if self.status.is_some() {
2818 len += 1;
2819 }
2820 if self.version.is_some() {
2821 len += 1;
2822 }
2823 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2824 if let Some(v) = self.status.as_ref() {
2825 struct_ser.serialize_field("status", v)?;
2826 }
2827 if let Some(v) = self.version.as_ref() {
2828 struct_ser.serialize_field("version", v)?;
2829 }
2830 struct_ser.end()
2831 }
2832}
2833impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2834 #[allow(deprecated)]
2835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2836 where
2837 D: serde::Deserializer<'de>,
2838 {
2839 const FIELDS: &[&str] = &[
2840 "status",
2841 "version",
2842 ];
2843
2844 #[allow(clippy::enum_variant_names)]
2845 enum GeneratedField {
2846 Status,
2847 Version,
2848 }
2849 impl<'de> serde::Deserialize<'de> for GeneratedField {
2850 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2851 where
2852 D: serde::Deserializer<'de>,
2853 {
2854 struct GeneratedVisitor;
2855
2856 impl serde::de::Visitor<'_> for GeneratedVisitor {
2857 type Value = GeneratedField;
2858
2859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2860 write!(formatter, "expected one of: {:?}", &FIELDS)
2861 }
2862
2863 #[allow(unused_variables)]
2864 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2865 where
2866 E: serde::de::Error,
2867 {
2868 match value {
2869 "status" => Ok(GeneratedField::Status),
2870 "version" => Ok(GeneratedField::Version),
2871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2872 }
2873 }
2874 }
2875 deserializer.deserialize_identifier(GeneratedVisitor)
2876 }
2877 }
2878 struct GeneratedVisitor;
2879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2880 type Value = AlterSourceResponse;
2881
2882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2883 formatter.write_str("struct ddl_service.AlterSourceResponse")
2884 }
2885
2886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2887 where
2888 V: serde::de::MapAccess<'de>,
2889 {
2890 let mut status__ = None;
2891 let mut version__ = None;
2892 while let Some(k) = map_.next_key()? {
2893 match k {
2894 GeneratedField::Status => {
2895 if status__.is_some() {
2896 return Err(serde::de::Error::duplicate_field("status"));
2897 }
2898 status__ = map_.next_value()?;
2899 }
2900 GeneratedField::Version => {
2901 if version__.is_some() {
2902 return Err(serde::de::Error::duplicate_field("version"));
2903 }
2904 version__ = map_.next_value()?;
2905 }
2906 }
2907 }
2908 Ok(AlterSourceResponse {
2909 status: status__,
2910 version: version__,
2911 })
2912 }
2913 }
2914 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2915 }
2916}
2917impl serde::Serialize for AlterStreamingJobConfigRequest {
2918 #[allow(deprecated)]
2919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2920 where
2921 S: serde::Serializer,
2922 {
2923 use serde::ser::SerializeStruct;
2924 let mut len = 0;
2925 if self.job_id != 0 {
2926 len += 1;
2927 }
2928 if !self.entries_to_add.is_empty() {
2929 len += 1;
2930 }
2931 if !self.keys_to_remove.is_empty() {
2932 len += 1;
2933 }
2934 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigRequest", len)?;
2935 if self.job_id != 0 {
2936 struct_ser.serialize_field("jobId", &self.job_id)?;
2937 }
2938 if !self.entries_to_add.is_empty() {
2939 struct_ser.serialize_field("entriesToAdd", &self.entries_to_add)?;
2940 }
2941 if !self.keys_to_remove.is_empty() {
2942 struct_ser.serialize_field("keysToRemove", &self.keys_to_remove)?;
2943 }
2944 struct_ser.end()
2945 }
2946}
2947impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigRequest {
2948 #[allow(deprecated)]
2949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2950 where
2951 D: serde::Deserializer<'de>,
2952 {
2953 const FIELDS: &[&str] = &[
2954 "job_id",
2955 "jobId",
2956 "entries_to_add",
2957 "entriesToAdd",
2958 "keys_to_remove",
2959 "keysToRemove",
2960 ];
2961
2962 #[allow(clippy::enum_variant_names)]
2963 enum GeneratedField {
2964 JobId,
2965 EntriesToAdd,
2966 KeysToRemove,
2967 }
2968 impl<'de> serde::Deserialize<'de> for GeneratedField {
2969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2970 where
2971 D: serde::Deserializer<'de>,
2972 {
2973 struct GeneratedVisitor;
2974
2975 impl serde::de::Visitor<'_> for GeneratedVisitor {
2976 type Value = GeneratedField;
2977
2978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2979 write!(formatter, "expected one of: {:?}", &FIELDS)
2980 }
2981
2982 #[allow(unused_variables)]
2983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2984 where
2985 E: serde::de::Error,
2986 {
2987 match value {
2988 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2989 "entriesToAdd" | "entries_to_add" => Ok(GeneratedField::EntriesToAdd),
2990 "keysToRemove" | "keys_to_remove" => Ok(GeneratedField::KeysToRemove),
2991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2992 }
2993 }
2994 }
2995 deserializer.deserialize_identifier(GeneratedVisitor)
2996 }
2997 }
2998 struct GeneratedVisitor;
2999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3000 type Value = AlterStreamingJobConfigRequest;
3001
3002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3003 formatter.write_str("struct ddl_service.AlterStreamingJobConfigRequest")
3004 }
3005
3006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigRequest, V::Error>
3007 where
3008 V: serde::de::MapAccess<'de>,
3009 {
3010 let mut job_id__ = None;
3011 let mut entries_to_add__ = None;
3012 let mut keys_to_remove__ = None;
3013 while let Some(k) = map_.next_key()? {
3014 match k {
3015 GeneratedField::JobId => {
3016 if job_id__.is_some() {
3017 return Err(serde::de::Error::duplicate_field("jobId"));
3018 }
3019 job_id__ =
3020 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3021 ;
3022 }
3023 GeneratedField::EntriesToAdd => {
3024 if entries_to_add__.is_some() {
3025 return Err(serde::de::Error::duplicate_field("entriesToAdd"));
3026 }
3027 entries_to_add__ = Some(
3028 map_.next_value::<std::collections::HashMap<_, _>>()?
3029 );
3030 }
3031 GeneratedField::KeysToRemove => {
3032 if keys_to_remove__.is_some() {
3033 return Err(serde::de::Error::duplicate_field("keysToRemove"));
3034 }
3035 keys_to_remove__ = Some(map_.next_value()?);
3036 }
3037 }
3038 }
3039 Ok(AlterStreamingJobConfigRequest {
3040 job_id: job_id__.unwrap_or_default(),
3041 entries_to_add: entries_to_add__.unwrap_or_default(),
3042 keys_to_remove: keys_to_remove__.unwrap_or_default(),
3043 })
3044 }
3045 }
3046 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigRequest", FIELDS, GeneratedVisitor)
3047 }
3048}
3049impl serde::Serialize for AlterStreamingJobConfigResponse {
3050 #[allow(deprecated)]
3051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3052 where
3053 S: serde::Serializer,
3054 {
3055 use serde::ser::SerializeStruct;
3056 let len = 0;
3057 let struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigResponse", len)?;
3058 struct_ser.end()
3059 }
3060}
3061impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigResponse {
3062 #[allow(deprecated)]
3063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3064 where
3065 D: serde::Deserializer<'de>,
3066 {
3067 const FIELDS: &[&str] = &[
3068 ];
3069
3070 #[allow(clippy::enum_variant_names)]
3071 enum GeneratedField {
3072 }
3073 impl<'de> serde::Deserialize<'de> for GeneratedField {
3074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3075 where
3076 D: serde::Deserializer<'de>,
3077 {
3078 struct GeneratedVisitor;
3079
3080 impl serde::de::Visitor<'_> for GeneratedVisitor {
3081 type Value = GeneratedField;
3082
3083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3084 write!(formatter, "expected one of: {:?}", &FIELDS)
3085 }
3086
3087 #[allow(unused_variables)]
3088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3089 where
3090 E: serde::de::Error,
3091 {
3092 Err(serde::de::Error::unknown_field(value, FIELDS))
3093 }
3094 }
3095 deserializer.deserialize_identifier(GeneratedVisitor)
3096 }
3097 }
3098 struct GeneratedVisitor;
3099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3100 type Value = AlterStreamingJobConfigResponse;
3101
3102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3103 formatter.write_str("struct ddl_service.AlterStreamingJobConfigResponse")
3104 }
3105
3106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigResponse, V::Error>
3107 where
3108 V: serde::de::MapAccess<'de>,
3109 {
3110 while map_.next_key::<GeneratedField>()?.is_some() {
3111 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3112 }
3113 Ok(AlterStreamingJobConfigResponse {
3114 })
3115 }
3116 }
3117 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigResponse", FIELDS, GeneratedVisitor)
3118 }
3119}
3120impl serde::Serialize for AlterSubscriptionRetentionRequest {
3121 #[allow(deprecated)]
3122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3123 where
3124 S: serde::Serializer,
3125 {
3126 use serde::ser::SerializeStruct;
3127 let mut len = 0;
3128 if self.subscription_id != 0 {
3129 len += 1;
3130 }
3131 if self.retention_seconds != 0 {
3132 len += 1;
3133 }
3134 if !self.definition.is_empty() {
3135 len += 1;
3136 }
3137 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionRequest", len)?;
3138 if self.subscription_id != 0 {
3139 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
3140 }
3141 if self.retention_seconds != 0 {
3142 #[allow(clippy::needless_borrow)]
3143 #[allow(clippy::needless_borrows_for_generic_args)]
3144 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
3145 }
3146 if !self.definition.is_empty() {
3147 struct_ser.serialize_field("definition", &self.definition)?;
3148 }
3149 struct_ser.end()
3150 }
3151}
3152impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionRequest {
3153 #[allow(deprecated)]
3154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3155 where
3156 D: serde::Deserializer<'de>,
3157 {
3158 const FIELDS: &[&str] = &[
3159 "subscription_id",
3160 "subscriptionId",
3161 "retention_seconds",
3162 "retentionSeconds",
3163 "definition",
3164 ];
3165
3166 #[allow(clippy::enum_variant_names)]
3167 enum GeneratedField {
3168 SubscriptionId,
3169 RetentionSeconds,
3170 Definition,
3171 }
3172 impl<'de> serde::Deserialize<'de> for GeneratedField {
3173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3174 where
3175 D: serde::Deserializer<'de>,
3176 {
3177 struct GeneratedVisitor;
3178
3179 impl serde::de::Visitor<'_> for GeneratedVisitor {
3180 type Value = GeneratedField;
3181
3182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3183 write!(formatter, "expected one of: {:?}", &FIELDS)
3184 }
3185
3186 #[allow(unused_variables)]
3187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3188 where
3189 E: serde::de::Error,
3190 {
3191 match value {
3192 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
3193 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
3194 "definition" => Ok(GeneratedField::Definition),
3195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3196 }
3197 }
3198 }
3199 deserializer.deserialize_identifier(GeneratedVisitor)
3200 }
3201 }
3202 struct GeneratedVisitor;
3203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3204 type Value = AlterSubscriptionRetentionRequest;
3205
3206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3207 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionRequest")
3208 }
3209
3210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionRequest, V::Error>
3211 where
3212 V: serde::de::MapAccess<'de>,
3213 {
3214 let mut subscription_id__ = None;
3215 let mut retention_seconds__ = None;
3216 let mut definition__ = None;
3217 while let Some(k) = map_.next_key()? {
3218 match k {
3219 GeneratedField::SubscriptionId => {
3220 if subscription_id__.is_some() {
3221 return Err(serde::de::Error::duplicate_field("subscriptionId"));
3222 }
3223 subscription_id__ =
3224 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3225 ;
3226 }
3227 GeneratedField::RetentionSeconds => {
3228 if retention_seconds__.is_some() {
3229 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
3230 }
3231 retention_seconds__ =
3232 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3233 ;
3234 }
3235 GeneratedField::Definition => {
3236 if definition__.is_some() {
3237 return Err(serde::de::Error::duplicate_field("definition"));
3238 }
3239 definition__ = Some(map_.next_value()?);
3240 }
3241 }
3242 }
3243 Ok(AlterSubscriptionRetentionRequest {
3244 subscription_id: subscription_id__.unwrap_or_default(),
3245 retention_seconds: retention_seconds__.unwrap_or_default(),
3246 definition: definition__.unwrap_or_default(),
3247 })
3248 }
3249 }
3250 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionRequest", FIELDS, GeneratedVisitor)
3251 }
3252}
3253impl serde::Serialize for AlterSubscriptionRetentionResponse {
3254 #[allow(deprecated)]
3255 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3256 where
3257 S: serde::Serializer,
3258 {
3259 use serde::ser::SerializeStruct;
3260 let mut len = 0;
3261 if self.status.is_some() {
3262 len += 1;
3263 }
3264 if self.version.is_some() {
3265 len += 1;
3266 }
3267 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSubscriptionRetentionResponse", len)?;
3268 if let Some(v) = self.status.as_ref() {
3269 struct_ser.serialize_field("status", v)?;
3270 }
3271 if let Some(v) = self.version.as_ref() {
3272 struct_ser.serialize_field("version", v)?;
3273 }
3274 struct_ser.end()
3275 }
3276}
3277impl<'de> serde::Deserialize<'de> for AlterSubscriptionRetentionResponse {
3278 #[allow(deprecated)]
3279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3280 where
3281 D: serde::Deserializer<'de>,
3282 {
3283 const FIELDS: &[&str] = &[
3284 "status",
3285 "version",
3286 ];
3287
3288 #[allow(clippy::enum_variant_names)]
3289 enum GeneratedField {
3290 Status,
3291 Version,
3292 }
3293 impl<'de> serde::Deserialize<'de> for GeneratedField {
3294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3295 where
3296 D: serde::Deserializer<'de>,
3297 {
3298 struct GeneratedVisitor;
3299
3300 impl serde::de::Visitor<'_> for GeneratedVisitor {
3301 type Value = GeneratedField;
3302
3303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3304 write!(formatter, "expected one of: {:?}", &FIELDS)
3305 }
3306
3307 #[allow(unused_variables)]
3308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3309 where
3310 E: serde::de::Error,
3311 {
3312 match value {
3313 "status" => Ok(GeneratedField::Status),
3314 "version" => Ok(GeneratedField::Version),
3315 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3316 }
3317 }
3318 }
3319 deserializer.deserialize_identifier(GeneratedVisitor)
3320 }
3321 }
3322 struct GeneratedVisitor;
3323 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3324 type Value = AlterSubscriptionRetentionResponse;
3325
3326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3327 formatter.write_str("struct ddl_service.AlterSubscriptionRetentionResponse")
3328 }
3329
3330 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSubscriptionRetentionResponse, V::Error>
3331 where
3332 V: serde::de::MapAccess<'de>,
3333 {
3334 let mut status__ = None;
3335 let mut version__ = None;
3336 while let Some(k) = map_.next_key()? {
3337 match k {
3338 GeneratedField::Status => {
3339 if status__.is_some() {
3340 return Err(serde::de::Error::duplicate_field("status"));
3341 }
3342 status__ = map_.next_value()?;
3343 }
3344 GeneratedField::Version => {
3345 if version__.is_some() {
3346 return Err(serde::de::Error::duplicate_field("version"));
3347 }
3348 version__ = map_.next_value()?;
3349 }
3350 }
3351 }
3352 Ok(AlterSubscriptionRetentionResponse {
3353 status: status__,
3354 version: version__,
3355 })
3356 }
3357 }
3358 deserializer.deserialize_struct("ddl_service.AlterSubscriptionRetentionResponse", FIELDS, GeneratedVisitor)
3359 }
3360}
3361impl serde::Serialize for AlterSwapRenameRequest {
3362 #[allow(deprecated)]
3363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3364 where
3365 S: serde::Serializer,
3366 {
3367 use serde::ser::SerializeStruct;
3368 let mut len = 0;
3369 if self.object.is_some() {
3370 len += 1;
3371 }
3372 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
3373 if let Some(v) = self.object.as_ref() {
3374 match v {
3375 alter_swap_rename_request::Object::Schema(v) => {
3376 struct_ser.serialize_field("schema", v)?;
3377 }
3378 alter_swap_rename_request::Object::Table(v) => {
3379 struct_ser.serialize_field("table", v)?;
3380 }
3381 alter_swap_rename_request::Object::View(v) => {
3382 struct_ser.serialize_field("view", v)?;
3383 }
3384 alter_swap_rename_request::Object::Source(v) => {
3385 struct_ser.serialize_field("source", v)?;
3386 }
3387 alter_swap_rename_request::Object::Sink(v) => {
3388 struct_ser.serialize_field("sink", v)?;
3389 }
3390 alter_swap_rename_request::Object::Subscription(v) => {
3391 struct_ser.serialize_field("subscription", v)?;
3392 }
3393 }
3394 }
3395 struct_ser.end()
3396 }
3397}
3398impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
3399 #[allow(deprecated)]
3400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3401 where
3402 D: serde::Deserializer<'de>,
3403 {
3404 const FIELDS: &[&str] = &[
3405 "schema",
3406 "table",
3407 "view",
3408 "source",
3409 "sink",
3410 "subscription",
3411 ];
3412
3413 #[allow(clippy::enum_variant_names)]
3414 enum GeneratedField {
3415 Schema,
3416 Table,
3417 View,
3418 Source,
3419 Sink,
3420 Subscription,
3421 }
3422 impl<'de> serde::Deserialize<'de> for GeneratedField {
3423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3424 where
3425 D: serde::Deserializer<'de>,
3426 {
3427 struct GeneratedVisitor;
3428
3429 impl serde::de::Visitor<'_> for GeneratedVisitor {
3430 type Value = GeneratedField;
3431
3432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3433 write!(formatter, "expected one of: {:?}", &FIELDS)
3434 }
3435
3436 #[allow(unused_variables)]
3437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3438 where
3439 E: serde::de::Error,
3440 {
3441 match value {
3442 "schema" => Ok(GeneratedField::Schema),
3443 "table" => Ok(GeneratedField::Table),
3444 "view" => Ok(GeneratedField::View),
3445 "source" => Ok(GeneratedField::Source),
3446 "sink" => Ok(GeneratedField::Sink),
3447 "subscription" => Ok(GeneratedField::Subscription),
3448 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3449 }
3450 }
3451 }
3452 deserializer.deserialize_identifier(GeneratedVisitor)
3453 }
3454 }
3455 struct GeneratedVisitor;
3456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3457 type Value = AlterSwapRenameRequest;
3458
3459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3460 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
3461 }
3462
3463 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
3464 where
3465 V: serde::de::MapAccess<'de>,
3466 {
3467 let mut object__ = None;
3468 while let Some(k) = map_.next_key()? {
3469 match k {
3470 GeneratedField::Schema => {
3471 if object__.is_some() {
3472 return Err(serde::de::Error::duplicate_field("schema"));
3473 }
3474 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
3475;
3476 }
3477 GeneratedField::Table => {
3478 if object__.is_some() {
3479 return Err(serde::de::Error::duplicate_field("table"));
3480 }
3481 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
3482;
3483 }
3484 GeneratedField::View => {
3485 if object__.is_some() {
3486 return Err(serde::de::Error::duplicate_field("view"));
3487 }
3488 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
3489;
3490 }
3491 GeneratedField::Source => {
3492 if object__.is_some() {
3493 return Err(serde::de::Error::duplicate_field("source"));
3494 }
3495 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
3496;
3497 }
3498 GeneratedField::Sink => {
3499 if object__.is_some() {
3500 return Err(serde::de::Error::duplicate_field("sink"));
3501 }
3502 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
3503;
3504 }
3505 GeneratedField::Subscription => {
3506 if object__.is_some() {
3507 return Err(serde::de::Error::duplicate_field("subscription"));
3508 }
3509 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
3510;
3511 }
3512 }
3513 }
3514 Ok(AlterSwapRenameRequest {
3515 object: object__,
3516 })
3517 }
3518 }
3519 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
3520 }
3521}
3522impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
3523 #[allow(deprecated)]
3524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3525 where
3526 S: serde::Serializer,
3527 {
3528 use serde::ser::SerializeStruct;
3529 let mut len = 0;
3530 if self.src_object_id != 0 {
3531 len += 1;
3532 }
3533 if self.dst_object_id != 0 {
3534 len += 1;
3535 }
3536 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
3537 if self.src_object_id != 0 {
3538 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
3539 }
3540 if self.dst_object_id != 0 {
3541 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
3542 }
3543 struct_ser.end()
3544 }
3545}
3546impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
3547 #[allow(deprecated)]
3548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3549 where
3550 D: serde::Deserializer<'de>,
3551 {
3552 const FIELDS: &[&str] = &[
3553 "src_object_id",
3554 "srcObjectId",
3555 "dst_object_id",
3556 "dstObjectId",
3557 ];
3558
3559 #[allow(clippy::enum_variant_names)]
3560 enum GeneratedField {
3561 SrcObjectId,
3562 DstObjectId,
3563 }
3564 impl<'de> serde::Deserialize<'de> for GeneratedField {
3565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3566 where
3567 D: serde::Deserializer<'de>,
3568 {
3569 struct GeneratedVisitor;
3570
3571 impl serde::de::Visitor<'_> for GeneratedVisitor {
3572 type Value = GeneratedField;
3573
3574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3575 write!(formatter, "expected one of: {:?}", &FIELDS)
3576 }
3577
3578 #[allow(unused_variables)]
3579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3580 where
3581 E: serde::de::Error,
3582 {
3583 match value {
3584 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
3585 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
3586 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3587 }
3588 }
3589 }
3590 deserializer.deserialize_identifier(GeneratedVisitor)
3591 }
3592 }
3593 struct GeneratedVisitor;
3594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3595 type Value = alter_swap_rename_request::ObjectNameSwapPair;
3596
3597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3598 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
3599 }
3600
3601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
3602 where
3603 V: serde::de::MapAccess<'de>,
3604 {
3605 let mut src_object_id__ = None;
3606 let mut dst_object_id__ = None;
3607 while let Some(k) = map_.next_key()? {
3608 match k {
3609 GeneratedField::SrcObjectId => {
3610 if src_object_id__.is_some() {
3611 return Err(serde::de::Error::duplicate_field("srcObjectId"));
3612 }
3613 src_object_id__ =
3614 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3615 ;
3616 }
3617 GeneratedField::DstObjectId => {
3618 if dst_object_id__.is_some() {
3619 return Err(serde::de::Error::duplicate_field("dstObjectId"));
3620 }
3621 dst_object_id__ =
3622 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3623 ;
3624 }
3625 }
3626 }
3627 Ok(alter_swap_rename_request::ObjectNameSwapPair {
3628 src_object_id: src_object_id__.unwrap_or_default(),
3629 dst_object_id: dst_object_id__.unwrap_or_default(),
3630 })
3631 }
3632 }
3633 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
3634 }
3635}
3636impl serde::Serialize for AlterSwapRenameResponse {
3637 #[allow(deprecated)]
3638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3639 where
3640 S: serde::Serializer,
3641 {
3642 use serde::ser::SerializeStruct;
3643 let mut len = 0;
3644 if self.status.is_some() {
3645 len += 1;
3646 }
3647 if self.version.is_some() {
3648 len += 1;
3649 }
3650 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
3651 if let Some(v) = self.status.as_ref() {
3652 struct_ser.serialize_field("status", v)?;
3653 }
3654 if let Some(v) = self.version.as_ref() {
3655 struct_ser.serialize_field("version", v)?;
3656 }
3657 struct_ser.end()
3658 }
3659}
3660impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
3661 #[allow(deprecated)]
3662 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3663 where
3664 D: serde::Deserializer<'de>,
3665 {
3666 const FIELDS: &[&str] = &[
3667 "status",
3668 "version",
3669 ];
3670
3671 #[allow(clippy::enum_variant_names)]
3672 enum GeneratedField {
3673 Status,
3674 Version,
3675 }
3676 impl<'de> serde::Deserialize<'de> for GeneratedField {
3677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3678 where
3679 D: serde::Deserializer<'de>,
3680 {
3681 struct GeneratedVisitor;
3682
3683 impl serde::de::Visitor<'_> for GeneratedVisitor {
3684 type Value = GeneratedField;
3685
3686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3687 write!(formatter, "expected one of: {:?}", &FIELDS)
3688 }
3689
3690 #[allow(unused_variables)]
3691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3692 where
3693 E: serde::de::Error,
3694 {
3695 match value {
3696 "status" => Ok(GeneratedField::Status),
3697 "version" => Ok(GeneratedField::Version),
3698 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3699 }
3700 }
3701 }
3702 deserializer.deserialize_identifier(GeneratedVisitor)
3703 }
3704 }
3705 struct GeneratedVisitor;
3706 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3707 type Value = AlterSwapRenameResponse;
3708
3709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3710 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
3711 }
3712
3713 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
3714 where
3715 V: serde::de::MapAccess<'de>,
3716 {
3717 let mut status__ = None;
3718 let mut version__ = None;
3719 while let Some(k) = map_.next_key()? {
3720 match k {
3721 GeneratedField::Status => {
3722 if status__.is_some() {
3723 return Err(serde::de::Error::duplicate_field("status"));
3724 }
3725 status__ = map_.next_value()?;
3726 }
3727 GeneratedField::Version => {
3728 if version__.is_some() {
3729 return Err(serde::de::Error::duplicate_field("version"));
3730 }
3731 version__ = map_.next_value()?;
3732 }
3733 }
3734 }
3735 Ok(AlterSwapRenameResponse {
3736 status: status__,
3737 version: version__,
3738 })
3739 }
3740 }
3741 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
3742 }
3743}
3744impl serde::Serialize for AutoSchemaChangeRequest {
3745 #[allow(deprecated)]
3746 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3747 where
3748 S: serde::Serializer,
3749 {
3750 use serde::ser::SerializeStruct;
3751 let mut len = 0;
3752 if self.schema_change.is_some() {
3753 len += 1;
3754 }
3755 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
3756 if let Some(v) = self.schema_change.as_ref() {
3757 struct_ser.serialize_field("schemaChange", v)?;
3758 }
3759 struct_ser.end()
3760 }
3761}
3762impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
3763 #[allow(deprecated)]
3764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3765 where
3766 D: serde::Deserializer<'de>,
3767 {
3768 const FIELDS: &[&str] = &[
3769 "schema_change",
3770 "schemaChange",
3771 ];
3772
3773 #[allow(clippy::enum_variant_names)]
3774 enum GeneratedField {
3775 SchemaChange,
3776 }
3777 impl<'de> serde::Deserialize<'de> for GeneratedField {
3778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3779 where
3780 D: serde::Deserializer<'de>,
3781 {
3782 struct GeneratedVisitor;
3783
3784 impl serde::de::Visitor<'_> for GeneratedVisitor {
3785 type Value = GeneratedField;
3786
3787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3788 write!(formatter, "expected one of: {:?}", &FIELDS)
3789 }
3790
3791 #[allow(unused_variables)]
3792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3793 where
3794 E: serde::de::Error,
3795 {
3796 match value {
3797 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
3798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3799 }
3800 }
3801 }
3802 deserializer.deserialize_identifier(GeneratedVisitor)
3803 }
3804 }
3805 struct GeneratedVisitor;
3806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3807 type Value = AutoSchemaChangeRequest;
3808
3809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3810 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
3811 }
3812
3813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
3814 where
3815 V: serde::de::MapAccess<'de>,
3816 {
3817 let mut schema_change__ = None;
3818 while let Some(k) = map_.next_key()? {
3819 match k {
3820 GeneratedField::SchemaChange => {
3821 if schema_change__.is_some() {
3822 return Err(serde::de::Error::duplicate_field("schemaChange"));
3823 }
3824 schema_change__ = map_.next_value()?;
3825 }
3826 }
3827 }
3828 Ok(AutoSchemaChangeRequest {
3829 schema_change: schema_change__,
3830 })
3831 }
3832 }
3833 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
3834 }
3835}
3836impl serde::Serialize for AutoSchemaChangeResponse {
3837 #[allow(deprecated)]
3838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3839 where
3840 S: serde::Serializer,
3841 {
3842 use serde::ser::SerializeStruct;
3843 let len = 0;
3844 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
3845 struct_ser.end()
3846 }
3847}
3848impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
3849 #[allow(deprecated)]
3850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3851 where
3852 D: serde::Deserializer<'de>,
3853 {
3854 const FIELDS: &[&str] = &[
3855 ];
3856
3857 #[allow(clippy::enum_variant_names)]
3858 enum GeneratedField {
3859 }
3860 impl<'de> serde::Deserialize<'de> for GeneratedField {
3861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3862 where
3863 D: serde::Deserializer<'de>,
3864 {
3865 struct GeneratedVisitor;
3866
3867 impl serde::de::Visitor<'_> for GeneratedVisitor {
3868 type Value = GeneratedField;
3869
3870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3871 write!(formatter, "expected one of: {:?}", &FIELDS)
3872 }
3873
3874 #[allow(unused_variables)]
3875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3876 where
3877 E: serde::de::Error,
3878 {
3879 Err(serde::de::Error::unknown_field(value, FIELDS))
3880 }
3881 }
3882 deserializer.deserialize_identifier(GeneratedVisitor)
3883 }
3884 }
3885 struct GeneratedVisitor;
3886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3887 type Value = AutoSchemaChangeResponse;
3888
3889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3890 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
3891 }
3892
3893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
3894 where
3895 V: serde::de::MapAccess<'de>,
3896 {
3897 while map_.next_key::<GeneratedField>()?.is_some() {
3898 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3899 }
3900 Ok(AutoSchemaChangeResponse {
3901 })
3902 }
3903 }
3904 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
3905 }
3906}
3907impl serde::Serialize for BackfillType {
3908 #[allow(deprecated)]
3909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3910 where
3911 S: serde::Serializer,
3912 {
3913 let variant = match self {
3914 Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
3915 Self::NormalBackfill => "NORMAL_BACKFILL",
3916 Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
3917 };
3918 serializer.serialize_str(variant)
3919 }
3920}
3921impl<'de> serde::Deserialize<'de> for BackfillType {
3922 #[allow(deprecated)]
3923 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3924 where
3925 D: serde::Deserializer<'de>,
3926 {
3927 const FIELDS: &[&str] = &[
3928 "BACKFILL_TYPE_UNSPECIFIED",
3929 "NORMAL_BACKFILL",
3930 "SNAPSHOT_BACKFILL",
3931 ];
3932
3933 struct GeneratedVisitor;
3934
3935 impl serde::de::Visitor<'_> for GeneratedVisitor {
3936 type Value = BackfillType;
3937
3938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3939 write!(formatter, "expected one of: {:?}", &FIELDS)
3940 }
3941
3942 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3943 where
3944 E: serde::de::Error,
3945 {
3946 i32::try_from(v)
3947 .ok()
3948 .and_then(|x| x.try_into().ok())
3949 .ok_or_else(|| {
3950 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3951 })
3952 }
3953
3954 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3955 where
3956 E: serde::de::Error,
3957 {
3958 i32::try_from(v)
3959 .ok()
3960 .and_then(|x| x.try_into().ok())
3961 .ok_or_else(|| {
3962 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3963 })
3964 }
3965
3966 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3967 where
3968 E: serde::de::Error,
3969 {
3970 match value {
3971 "BACKFILL_TYPE_UNSPECIFIED" => Ok(BackfillType::Unspecified),
3972 "NORMAL_BACKFILL" => Ok(BackfillType::NormalBackfill),
3973 "SNAPSHOT_BACKFILL" => Ok(BackfillType::SnapshotBackfill),
3974 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3975 }
3976 }
3977 }
3978 deserializer.deserialize_any(GeneratedVisitor)
3979 }
3980}
3981impl serde::Serialize for CommentOnRequest {
3982 #[allow(deprecated)]
3983 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3984 where
3985 S: serde::Serializer,
3986 {
3987 use serde::ser::SerializeStruct;
3988 let mut len = 0;
3989 if self.comment.is_some() {
3990 len += 1;
3991 }
3992 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
3993 if let Some(v) = self.comment.as_ref() {
3994 struct_ser.serialize_field("comment", v)?;
3995 }
3996 struct_ser.end()
3997 }
3998}
3999impl<'de> serde::Deserialize<'de> for CommentOnRequest {
4000 #[allow(deprecated)]
4001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4002 where
4003 D: serde::Deserializer<'de>,
4004 {
4005 const FIELDS: &[&str] = &[
4006 "comment",
4007 ];
4008
4009 #[allow(clippy::enum_variant_names)]
4010 enum GeneratedField {
4011 Comment,
4012 }
4013 impl<'de> serde::Deserialize<'de> for GeneratedField {
4014 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4015 where
4016 D: serde::Deserializer<'de>,
4017 {
4018 struct GeneratedVisitor;
4019
4020 impl serde::de::Visitor<'_> for GeneratedVisitor {
4021 type Value = GeneratedField;
4022
4023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4024 write!(formatter, "expected one of: {:?}", &FIELDS)
4025 }
4026
4027 #[allow(unused_variables)]
4028 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4029 where
4030 E: serde::de::Error,
4031 {
4032 match value {
4033 "comment" => Ok(GeneratedField::Comment),
4034 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4035 }
4036 }
4037 }
4038 deserializer.deserialize_identifier(GeneratedVisitor)
4039 }
4040 }
4041 struct GeneratedVisitor;
4042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4043 type Value = CommentOnRequest;
4044
4045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4046 formatter.write_str("struct ddl_service.CommentOnRequest")
4047 }
4048
4049 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
4050 where
4051 V: serde::de::MapAccess<'de>,
4052 {
4053 let mut comment__ = None;
4054 while let Some(k) = map_.next_key()? {
4055 match k {
4056 GeneratedField::Comment => {
4057 if comment__.is_some() {
4058 return Err(serde::de::Error::duplicate_field("comment"));
4059 }
4060 comment__ = map_.next_value()?;
4061 }
4062 }
4063 }
4064 Ok(CommentOnRequest {
4065 comment: comment__,
4066 })
4067 }
4068 }
4069 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
4070 }
4071}
4072impl serde::Serialize for CommentOnResponse {
4073 #[allow(deprecated)]
4074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4075 where
4076 S: serde::Serializer,
4077 {
4078 use serde::ser::SerializeStruct;
4079 let mut len = 0;
4080 if self.status.is_some() {
4081 len += 1;
4082 }
4083 if self.version.is_some() {
4084 len += 1;
4085 }
4086 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
4087 if let Some(v) = self.status.as_ref() {
4088 struct_ser.serialize_field("status", v)?;
4089 }
4090 if let Some(v) = self.version.as_ref() {
4091 struct_ser.serialize_field("version", v)?;
4092 }
4093 struct_ser.end()
4094 }
4095}
4096impl<'de> serde::Deserialize<'de> for CommentOnResponse {
4097 #[allow(deprecated)]
4098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4099 where
4100 D: serde::Deserializer<'de>,
4101 {
4102 const FIELDS: &[&str] = &[
4103 "status",
4104 "version",
4105 ];
4106
4107 #[allow(clippy::enum_variant_names)]
4108 enum GeneratedField {
4109 Status,
4110 Version,
4111 }
4112 impl<'de> serde::Deserialize<'de> for GeneratedField {
4113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4114 where
4115 D: serde::Deserializer<'de>,
4116 {
4117 struct GeneratedVisitor;
4118
4119 impl serde::de::Visitor<'_> for GeneratedVisitor {
4120 type Value = GeneratedField;
4121
4122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4123 write!(formatter, "expected one of: {:?}", &FIELDS)
4124 }
4125
4126 #[allow(unused_variables)]
4127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4128 where
4129 E: serde::de::Error,
4130 {
4131 match value {
4132 "status" => Ok(GeneratedField::Status),
4133 "version" => Ok(GeneratedField::Version),
4134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4135 }
4136 }
4137 }
4138 deserializer.deserialize_identifier(GeneratedVisitor)
4139 }
4140 }
4141 struct GeneratedVisitor;
4142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4143 type Value = CommentOnResponse;
4144
4145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4146 formatter.write_str("struct ddl_service.CommentOnResponse")
4147 }
4148
4149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
4150 where
4151 V: serde::de::MapAccess<'de>,
4152 {
4153 let mut status__ = None;
4154 let mut version__ = None;
4155 while let Some(k) = map_.next_key()? {
4156 match k {
4157 GeneratedField::Status => {
4158 if status__.is_some() {
4159 return Err(serde::de::Error::duplicate_field("status"));
4160 }
4161 status__ = map_.next_value()?;
4162 }
4163 GeneratedField::Version => {
4164 if version__.is_some() {
4165 return Err(serde::de::Error::duplicate_field("version"));
4166 }
4167 version__ = map_.next_value()?;
4168 }
4169 }
4170 }
4171 Ok(CommentOnResponse {
4172 status: status__,
4173 version: version__,
4174 })
4175 }
4176 }
4177 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
4178 }
4179}
4180impl serde::Serialize for CompactIcebergTableRequest {
4181 #[allow(deprecated)]
4182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4183 where
4184 S: serde::Serializer,
4185 {
4186 use serde::ser::SerializeStruct;
4187 let mut len = 0;
4188 if self.sink_id != 0 {
4189 len += 1;
4190 }
4191 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
4192 if self.sink_id != 0 {
4193 struct_ser.serialize_field("sinkId", &self.sink_id)?;
4194 }
4195 struct_ser.end()
4196 }
4197}
4198impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
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 "sink_id",
4206 "sinkId",
4207 ];
4208
4209 #[allow(clippy::enum_variant_names)]
4210 enum GeneratedField {
4211 SinkId,
4212 }
4213 impl<'de> serde::Deserialize<'de> for GeneratedField {
4214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4215 where
4216 D: serde::Deserializer<'de>,
4217 {
4218 struct GeneratedVisitor;
4219
4220 impl serde::de::Visitor<'_> for GeneratedVisitor {
4221 type Value = GeneratedField;
4222
4223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4224 write!(formatter, "expected one of: {:?}", &FIELDS)
4225 }
4226
4227 #[allow(unused_variables)]
4228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4229 where
4230 E: serde::de::Error,
4231 {
4232 match value {
4233 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4235 }
4236 }
4237 }
4238 deserializer.deserialize_identifier(GeneratedVisitor)
4239 }
4240 }
4241 struct GeneratedVisitor;
4242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4243 type Value = CompactIcebergTableRequest;
4244
4245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4246 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
4247 }
4248
4249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
4250 where
4251 V: serde::de::MapAccess<'de>,
4252 {
4253 let mut sink_id__ = None;
4254 while let Some(k) = map_.next_key()? {
4255 match k {
4256 GeneratedField::SinkId => {
4257 if sink_id__.is_some() {
4258 return Err(serde::de::Error::duplicate_field("sinkId"));
4259 }
4260 sink_id__ =
4261 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4262 ;
4263 }
4264 }
4265 }
4266 Ok(CompactIcebergTableRequest {
4267 sink_id: sink_id__.unwrap_or_default(),
4268 })
4269 }
4270 }
4271 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
4272 }
4273}
4274impl serde::Serialize for CompactIcebergTableResponse {
4275 #[allow(deprecated)]
4276 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4277 where
4278 S: serde::Serializer,
4279 {
4280 use serde::ser::SerializeStruct;
4281 let mut len = 0;
4282 if self.status.is_some() {
4283 len += 1;
4284 }
4285 if self.task_id != 0 {
4286 len += 1;
4287 }
4288 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
4289 if let Some(v) = self.status.as_ref() {
4290 struct_ser.serialize_field("status", v)?;
4291 }
4292 if self.task_id != 0 {
4293 #[allow(clippy::needless_borrow)]
4294 #[allow(clippy::needless_borrows_for_generic_args)]
4295 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
4296 }
4297 struct_ser.end()
4298 }
4299}
4300impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
4301 #[allow(deprecated)]
4302 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4303 where
4304 D: serde::Deserializer<'de>,
4305 {
4306 const FIELDS: &[&str] = &[
4307 "status",
4308 "task_id",
4309 "taskId",
4310 ];
4311
4312 #[allow(clippy::enum_variant_names)]
4313 enum GeneratedField {
4314 Status,
4315 TaskId,
4316 }
4317 impl<'de> serde::Deserialize<'de> for GeneratedField {
4318 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4319 where
4320 D: serde::Deserializer<'de>,
4321 {
4322 struct GeneratedVisitor;
4323
4324 impl serde::de::Visitor<'_> for GeneratedVisitor {
4325 type Value = GeneratedField;
4326
4327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4328 write!(formatter, "expected one of: {:?}", &FIELDS)
4329 }
4330
4331 #[allow(unused_variables)]
4332 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4333 where
4334 E: serde::de::Error,
4335 {
4336 match value {
4337 "status" => Ok(GeneratedField::Status),
4338 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
4339 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4340 }
4341 }
4342 }
4343 deserializer.deserialize_identifier(GeneratedVisitor)
4344 }
4345 }
4346 struct GeneratedVisitor;
4347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4348 type Value = CompactIcebergTableResponse;
4349
4350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4351 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
4352 }
4353
4354 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
4355 where
4356 V: serde::de::MapAccess<'de>,
4357 {
4358 let mut status__ = None;
4359 let mut task_id__ = None;
4360 while let Some(k) = map_.next_key()? {
4361 match k {
4362 GeneratedField::Status => {
4363 if status__.is_some() {
4364 return Err(serde::de::Error::duplicate_field("status"));
4365 }
4366 status__ = map_.next_value()?;
4367 }
4368 GeneratedField::TaskId => {
4369 if task_id__.is_some() {
4370 return Err(serde::de::Error::duplicate_field("taskId"));
4371 }
4372 task_id__ =
4373 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4374 ;
4375 }
4376 }
4377 }
4378 Ok(CompactIcebergTableResponse {
4379 status: status__,
4380 task_id: task_id__.unwrap_or_default(),
4381 })
4382 }
4383 }
4384 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
4385 }
4386}
4387impl serde::Serialize for CreateConnectionRequest {
4388 #[allow(deprecated)]
4389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4390 where
4391 S: serde::Serializer,
4392 {
4393 use serde::ser::SerializeStruct;
4394 let mut len = 0;
4395 if !self.name.is_empty() {
4396 len += 1;
4397 }
4398 if self.database_id != 0 {
4399 len += 1;
4400 }
4401 if self.schema_id != 0 {
4402 len += 1;
4403 }
4404 if self.owner_id != 0 {
4405 len += 1;
4406 }
4407 if self.payload.is_some() {
4408 len += 1;
4409 }
4410 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
4411 if !self.name.is_empty() {
4412 struct_ser.serialize_field("name", &self.name)?;
4413 }
4414 if self.database_id != 0 {
4415 struct_ser.serialize_field("databaseId", &self.database_id)?;
4416 }
4417 if self.schema_id != 0 {
4418 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4419 }
4420 if self.owner_id != 0 {
4421 struct_ser.serialize_field("ownerId", &self.owner_id)?;
4422 }
4423 if let Some(v) = self.payload.as_ref() {
4424 match v {
4425 create_connection_request::Payload::PrivateLink(v) => {
4426 struct_ser.serialize_field("privateLink", v)?;
4427 }
4428 create_connection_request::Payload::ConnectionParams(v) => {
4429 struct_ser.serialize_field("connectionParams", v)?;
4430 }
4431 }
4432 }
4433 struct_ser.end()
4434 }
4435}
4436impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
4437 #[allow(deprecated)]
4438 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4439 where
4440 D: serde::Deserializer<'de>,
4441 {
4442 const FIELDS: &[&str] = &[
4443 "name",
4444 "database_id",
4445 "databaseId",
4446 "schema_id",
4447 "schemaId",
4448 "owner_id",
4449 "ownerId",
4450 "private_link",
4451 "privateLink",
4452 "connection_params",
4453 "connectionParams",
4454 ];
4455
4456 #[allow(clippy::enum_variant_names)]
4457 enum GeneratedField {
4458 Name,
4459 DatabaseId,
4460 SchemaId,
4461 OwnerId,
4462 PrivateLink,
4463 ConnectionParams,
4464 }
4465 impl<'de> serde::Deserialize<'de> for GeneratedField {
4466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4467 where
4468 D: serde::Deserializer<'de>,
4469 {
4470 struct GeneratedVisitor;
4471
4472 impl serde::de::Visitor<'_> for GeneratedVisitor {
4473 type Value = GeneratedField;
4474
4475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4476 write!(formatter, "expected one of: {:?}", &FIELDS)
4477 }
4478
4479 #[allow(unused_variables)]
4480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4481 where
4482 E: serde::de::Error,
4483 {
4484 match value {
4485 "name" => Ok(GeneratedField::Name),
4486 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4487 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4488 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
4489 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
4490 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
4491 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4492 }
4493 }
4494 }
4495 deserializer.deserialize_identifier(GeneratedVisitor)
4496 }
4497 }
4498 struct GeneratedVisitor;
4499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4500 type Value = CreateConnectionRequest;
4501
4502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4503 formatter.write_str("struct ddl_service.CreateConnectionRequest")
4504 }
4505
4506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
4507 where
4508 V: serde::de::MapAccess<'de>,
4509 {
4510 let mut name__ = None;
4511 let mut database_id__ = None;
4512 let mut schema_id__ = None;
4513 let mut owner_id__ = None;
4514 let mut payload__ = None;
4515 while let Some(k) = map_.next_key()? {
4516 match k {
4517 GeneratedField::Name => {
4518 if name__.is_some() {
4519 return Err(serde::de::Error::duplicate_field("name"));
4520 }
4521 name__ = Some(map_.next_value()?);
4522 }
4523 GeneratedField::DatabaseId => {
4524 if database_id__.is_some() {
4525 return Err(serde::de::Error::duplicate_field("databaseId"));
4526 }
4527 database_id__ =
4528 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4529 ;
4530 }
4531 GeneratedField::SchemaId => {
4532 if schema_id__.is_some() {
4533 return Err(serde::de::Error::duplicate_field("schemaId"));
4534 }
4535 schema_id__ =
4536 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4537 ;
4538 }
4539 GeneratedField::OwnerId => {
4540 if owner_id__.is_some() {
4541 return Err(serde::de::Error::duplicate_field("ownerId"));
4542 }
4543 owner_id__ =
4544 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4545 ;
4546 }
4547 GeneratedField::PrivateLink => {
4548 if payload__.is_some() {
4549 return Err(serde::de::Error::duplicate_field("privateLink"));
4550 }
4551 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
4552;
4553 }
4554 GeneratedField::ConnectionParams => {
4555 if payload__.is_some() {
4556 return Err(serde::de::Error::duplicate_field("connectionParams"));
4557 }
4558 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
4559;
4560 }
4561 }
4562 }
4563 Ok(CreateConnectionRequest {
4564 name: name__.unwrap_or_default(),
4565 database_id: database_id__.unwrap_or_default(),
4566 schema_id: schema_id__.unwrap_or_default(),
4567 owner_id: owner_id__.unwrap_or_default(),
4568 payload: payload__,
4569 })
4570 }
4571 }
4572 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
4573 }
4574}
4575impl serde::Serialize for create_connection_request::PrivateLink {
4576 #[allow(deprecated)]
4577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4578 where
4579 S: serde::Serializer,
4580 {
4581 use serde::ser::SerializeStruct;
4582 let mut len = 0;
4583 if self.provider != 0 {
4584 len += 1;
4585 }
4586 if !self.service_name.is_empty() {
4587 len += 1;
4588 }
4589 if self.tags.is_some() {
4590 len += 1;
4591 }
4592 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
4593 if self.provider != 0 {
4594 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
4595 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
4596 struct_ser.serialize_field("provider", &v)?;
4597 }
4598 if !self.service_name.is_empty() {
4599 struct_ser.serialize_field("serviceName", &self.service_name)?;
4600 }
4601 if let Some(v) = self.tags.as_ref() {
4602 struct_ser.serialize_field("tags", v)?;
4603 }
4604 struct_ser.end()
4605 }
4606}
4607impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
4608 #[allow(deprecated)]
4609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4610 where
4611 D: serde::Deserializer<'de>,
4612 {
4613 const FIELDS: &[&str] = &[
4614 "provider",
4615 "service_name",
4616 "serviceName",
4617 "tags",
4618 ];
4619
4620 #[allow(clippy::enum_variant_names)]
4621 enum GeneratedField {
4622 Provider,
4623 ServiceName,
4624 Tags,
4625 }
4626 impl<'de> serde::Deserialize<'de> for GeneratedField {
4627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4628 where
4629 D: serde::Deserializer<'de>,
4630 {
4631 struct GeneratedVisitor;
4632
4633 impl serde::de::Visitor<'_> for GeneratedVisitor {
4634 type Value = GeneratedField;
4635
4636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4637 write!(formatter, "expected one of: {:?}", &FIELDS)
4638 }
4639
4640 #[allow(unused_variables)]
4641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4642 where
4643 E: serde::de::Error,
4644 {
4645 match value {
4646 "provider" => Ok(GeneratedField::Provider),
4647 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
4648 "tags" => Ok(GeneratedField::Tags),
4649 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4650 }
4651 }
4652 }
4653 deserializer.deserialize_identifier(GeneratedVisitor)
4654 }
4655 }
4656 struct GeneratedVisitor;
4657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4658 type Value = create_connection_request::PrivateLink;
4659
4660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4661 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
4662 }
4663
4664 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
4665 where
4666 V: serde::de::MapAccess<'de>,
4667 {
4668 let mut provider__ = None;
4669 let mut service_name__ = None;
4670 let mut tags__ = None;
4671 while let Some(k) = map_.next_key()? {
4672 match k {
4673 GeneratedField::Provider => {
4674 if provider__.is_some() {
4675 return Err(serde::de::Error::duplicate_field("provider"));
4676 }
4677 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
4678 }
4679 GeneratedField::ServiceName => {
4680 if service_name__.is_some() {
4681 return Err(serde::de::Error::duplicate_field("serviceName"));
4682 }
4683 service_name__ = Some(map_.next_value()?);
4684 }
4685 GeneratedField::Tags => {
4686 if tags__.is_some() {
4687 return Err(serde::de::Error::duplicate_field("tags"));
4688 }
4689 tags__ = map_.next_value()?;
4690 }
4691 }
4692 }
4693 Ok(create_connection_request::PrivateLink {
4694 provider: provider__.unwrap_or_default(),
4695 service_name: service_name__.unwrap_or_default(),
4696 tags: tags__,
4697 })
4698 }
4699 }
4700 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
4701 }
4702}
4703impl serde::Serialize for CreateConnectionResponse {
4704 #[allow(deprecated)]
4705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4706 where
4707 S: serde::Serializer,
4708 {
4709 use serde::ser::SerializeStruct;
4710 let mut len = 0;
4711 if self.version.is_some() {
4712 len += 1;
4713 }
4714 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
4715 if let Some(v) = self.version.as_ref() {
4716 struct_ser.serialize_field("version", v)?;
4717 }
4718 struct_ser.end()
4719 }
4720}
4721impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
4722 #[allow(deprecated)]
4723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4724 where
4725 D: serde::Deserializer<'de>,
4726 {
4727 const FIELDS: &[&str] = &[
4728 "version",
4729 ];
4730
4731 #[allow(clippy::enum_variant_names)]
4732 enum GeneratedField {
4733 Version,
4734 }
4735 impl<'de> serde::Deserialize<'de> for GeneratedField {
4736 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4737 where
4738 D: serde::Deserializer<'de>,
4739 {
4740 struct GeneratedVisitor;
4741
4742 impl serde::de::Visitor<'_> for GeneratedVisitor {
4743 type Value = GeneratedField;
4744
4745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4746 write!(formatter, "expected one of: {:?}", &FIELDS)
4747 }
4748
4749 #[allow(unused_variables)]
4750 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4751 where
4752 E: serde::de::Error,
4753 {
4754 match value {
4755 "version" => Ok(GeneratedField::Version),
4756 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4757 }
4758 }
4759 }
4760 deserializer.deserialize_identifier(GeneratedVisitor)
4761 }
4762 }
4763 struct GeneratedVisitor;
4764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4765 type Value = CreateConnectionResponse;
4766
4767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4768 formatter.write_str("struct ddl_service.CreateConnectionResponse")
4769 }
4770
4771 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
4772 where
4773 V: serde::de::MapAccess<'de>,
4774 {
4775 let mut version__ = None;
4776 while let Some(k) = map_.next_key()? {
4777 match k {
4778 GeneratedField::Version => {
4779 if version__.is_some() {
4780 return Err(serde::de::Error::duplicate_field("version"));
4781 }
4782 version__ = map_.next_value()?;
4783 }
4784 }
4785 }
4786 Ok(CreateConnectionResponse {
4787 version: version__,
4788 })
4789 }
4790 }
4791 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
4792 }
4793}
4794impl serde::Serialize for CreateDatabaseRequest {
4795 #[allow(deprecated)]
4796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4797 where
4798 S: serde::Serializer,
4799 {
4800 use serde::ser::SerializeStruct;
4801 let mut len = 0;
4802 if self.db.is_some() {
4803 len += 1;
4804 }
4805 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
4806 if let Some(v) = self.db.as_ref() {
4807 struct_ser.serialize_field("db", v)?;
4808 }
4809 struct_ser.end()
4810 }
4811}
4812impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
4813 #[allow(deprecated)]
4814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4815 where
4816 D: serde::Deserializer<'de>,
4817 {
4818 const FIELDS: &[&str] = &[
4819 "db",
4820 ];
4821
4822 #[allow(clippy::enum_variant_names)]
4823 enum GeneratedField {
4824 Db,
4825 }
4826 impl<'de> serde::Deserialize<'de> for GeneratedField {
4827 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4828 where
4829 D: serde::Deserializer<'de>,
4830 {
4831 struct GeneratedVisitor;
4832
4833 impl serde::de::Visitor<'_> for GeneratedVisitor {
4834 type Value = GeneratedField;
4835
4836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4837 write!(formatter, "expected one of: {:?}", &FIELDS)
4838 }
4839
4840 #[allow(unused_variables)]
4841 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4842 where
4843 E: serde::de::Error,
4844 {
4845 match value {
4846 "db" => Ok(GeneratedField::Db),
4847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4848 }
4849 }
4850 }
4851 deserializer.deserialize_identifier(GeneratedVisitor)
4852 }
4853 }
4854 struct GeneratedVisitor;
4855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4856 type Value = CreateDatabaseRequest;
4857
4858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4859 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
4860 }
4861
4862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
4863 where
4864 V: serde::de::MapAccess<'de>,
4865 {
4866 let mut db__ = None;
4867 while let Some(k) = map_.next_key()? {
4868 match k {
4869 GeneratedField::Db => {
4870 if db__.is_some() {
4871 return Err(serde::de::Error::duplicate_field("db"));
4872 }
4873 db__ = map_.next_value()?;
4874 }
4875 }
4876 }
4877 Ok(CreateDatabaseRequest {
4878 db: db__,
4879 })
4880 }
4881 }
4882 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
4883 }
4884}
4885impl serde::Serialize for CreateDatabaseResponse {
4886 #[allow(deprecated)]
4887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4888 where
4889 S: serde::Serializer,
4890 {
4891 use serde::ser::SerializeStruct;
4892 let mut len = 0;
4893 if self.status.is_some() {
4894 len += 1;
4895 }
4896 if self.version.is_some() {
4897 len += 1;
4898 }
4899 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
4900 if let Some(v) = self.status.as_ref() {
4901 struct_ser.serialize_field("status", v)?;
4902 }
4903 if let Some(v) = self.version.as_ref() {
4904 struct_ser.serialize_field("version", v)?;
4905 }
4906 struct_ser.end()
4907 }
4908}
4909impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
4910 #[allow(deprecated)]
4911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4912 where
4913 D: serde::Deserializer<'de>,
4914 {
4915 const FIELDS: &[&str] = &[
4916 "status",
4917 "version",
4918 ];
4919
4920 #[allow(clippy::enum_variant_names)]
4921 enum GeneratedField {
4922 Status,
4923 Version,
4924 }
4925 impl<'de> serde::Deserialize<'de> for GeneratedField {
4926 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4927 where
4928 D: serde::Deserializer<'de>,
4929 {
4930 struct GeneratedVisitor;
4931
4932 impl serde::de::Visitor<'_> for GeneratedVisitor {
4933 type Value = GeneratedField;
4934
4935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4936 write!(formatter, "expected one of: {:?}", &FIELDS)
4937 }
4938
4939 #[allow(unused_variables)]
4940 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4941 where
4942 E: serde::de::Error,
4943 {
4944 match value {
4945 "status" => Ok(GeneratedField::Status),
4946 "version" => Ok(GeneratedField::Version),
4947 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4948 }
4949 }
4950 }
4951 deserializer.deserialize_identifier(GeneratedVisitor)
4952 }
4953 }
4954 struct GeneratedVisitor;
4955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4956 type Value = CreateDatabaseResponse;
4957
4958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4959 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
4960 }
4961
4962 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
4963 where
4964 V: serde::de::MapAccess<'de>,
4965 {
4966 let mut status__ = None;
4967 let mut version__ = None;
4968 while let Some(k) = map_.next_key()? {
4969 match k {
4970 GeneratedField::Status => {
4971 if status__.is_some() {
4972 return Err(serde::de::Error::duplicate_field("status"));
4973 }
4974 status__ = map_.next_value()?;
4975 }
4976 GeneratedField::Version => {
4977 if version__.is_some() {
4978 return Err(serde::de::Error::duplicate_field("version"));
4979 }
4980 version__ = map_.next_value()?;
4981 }
4982 }
4983 }
4984 Ok(CreateDatabaseResponse {
4985 status: status__,
4986 version: version__,
4987 })
4988 }
4989 }
4990 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
4991 }
4992}
4993impl serde::Serialize for CreateFunctionRequest {
4994 #[allow(deprecated)]
4995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4996 where
4997 S: serde::Serializer,
4998 {
4999 use serde::ser::SerializeStruct;
5000 let mut len = 0;
5001 if self.function.is_some() {
5002 len += 1;
5003 }
5004 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
5005 if let Some(v) = self.function.as_ref() {
5006 struct_ser.serialize_field("function", v)?;
5007 }
5008 struct_ser.end()
5009 }
5010}
5011impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
5012 #[allow(deprecated)]
5013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5014 where
5015 D: serde::Deserializer<'de>,
5016 {
5017 const FIELDS: &[&str] = &[
5018 "function",
5019 ];
5020
5021 #[allow(clippy::enum_variant_names)]
5022 enum GeneratedField {
5023 Function,
5024 }
5025 impl<'de> serde::Deserialize<'de> for GeneratedField {
5026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5027 where
5028 D: serde::Deserializer<'de>,
5029 {
5030 struct GeneratedVisitor;
5031
5032 impl serde::de::Visitor<'_> for GeneratedVisitor {
5033 type Value = GeneratedField;
5034
5035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5036 write!(formatter, "expected one of: {:?}", &FIELDS)
5037 }
5038
5039 #[allow(unused_variables)]
5040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5041 where
5042 E: serde::de::Error,
5043 {
5044 match value {
5045 "function" => Ok(GeneratedField::Function),
5046 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5047 }
5048 }
5049 }
5050 deserializer.deserialize_identifier(GeneratedVisitor)
5051 }
5052 }
5053 struct GeneratedVisitor;
5054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5055 type Value = CreateFunctionRequest;
5056
5057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5058 formatter.write_str("struct ddl_service.CreateFunctionRequest")
5059 }
5060
5061 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
5062 where
5063 V: serde::de::MapAccess<'de>,
5064 {
5065 let mut function__ = None;
5066 while let Some(k) = map_.next_key()? {
5067 match k {
5068 GeneratedField::Function => {
5069 if function__.is_some() {
5070 return Err(serde::de::Error::duplicate_field("function"));
5071 }
5072 function__ = map_.next_value()?;
5073 }
5074 }
5075 }
5076 Ok(CreateFunctionRequest {
5077 function: function__,
5078 })
5079 }
5080 }
5081 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
5082 }
5083}
5084impl serde::Serialize for CreateFunctionResponse {
5085 #[allow(deprecated)]
5086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5087 where
5088 S: serde::Serializer,
5089 {
5090 use serde::ser::SerializeStruct;
5091 let mut len = 0;
5092 if self.status.is_some() {
5093 len += 1;
5094 }
5095 if self.version.is_some() {
5096 len += 1;
5097 }
5098 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
5099 if let Some(v) = self.status.as_ref() {
5100 struct_ser.serialize_field("status", v)?;
5101 }
5102 if let Some(v) = self.version.as_ref() {
5103 struct_ser.serialize_field("version", v)?;
5104 }
5105 struct_ser.end()
5106 }
5107}
5108impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
5109 #[allow(deprecated)]
5110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5111 where
5112 D: serde::Deserializer<'de>,
5113 {
5114 const FIELDS: &[&str] = &[
5115 "status",
5116 "version",
5117 ];
5118
5119 #[allow(clippy::enum_variant_names)]
5120 enum GeneratedField {
5121 Status,
5122 Version,
5123 }
5124 impl<'de> serde::Deserialize<'de> for GeneratedField {
5125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5126 where
5127 D: serde::Deserializer<'de>,
5128 {
5129 struct GeneratedVisitor;
5130
5131 impl serde::de::Visitor<'_> for GeneratedVisitor {
5132 type Value = GeneratedField;
5133
5134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5135 write!(formatter, "expected one of: {:?}", &FIELDS)
5136 }
5137
5138 #[allow(unused_variables)]
5139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5140 where
5141 E: serde::de::Error,
5142 {
5143 match value {
5144 "status" => Ok(GeneratedField::Status),
5145 "version" => Ok(GeneratedField::Version),
5146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5147 }
5148 }
5149 }
5150 deserializer.deserialize_identifier(GeneratedVisitor)
5151 }
5152 }
5153 struct GeneratedVisitor;
5154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5155 type Value = CreateFunctionResponse;
5156
5157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5158 formatter.write_str("struct ddl_service.CreateFunctionResponse")
5159 }
5160
5161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
5162 where
5163 V: serde::de::MapAccess<'de>,
5164 {
5165 let mut status__ = None;
5166 let mut version__ = None;
5167 while let Some(k) = map_.next_key()? {
5168 match k {
5169 GeneratedField::Status => {
5170 if status__.is_some() {
5171 return Err(serde::de::Error::duplicate_field("status"));
5172 }
5173 status__ = map_.next_value()?;
5174 }
5175 GeneratedField::Version => {
5176 if version__.is_some() {
5177 return Err(serde::de::Error::duplicate_field("version"));
5178 }
5179 version__ = map_.next_value()?;
5180 }
5181 }
5182 }
5183 Ok(CreateFunctionResponse {
5184 status: status__,
5185 version: version__,
5186 })
5187 }
5188 }
5189 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
5190 }
5191}
5192impl serde::Serialize for CreateIcebergTableRequest {
5193 #[allow(deprecated)]
5194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5195 where
5196 S: serde::Serializer,
5197 {
5198 use serde::ser::SerializeStruct;
5199 let mut len = 0;
5200 if self.table_info.is_some() {
5201 len += 1;
5202 }
5203 if self.sink_info.is_some() {
5204 len += 1;
5205 }
5206 if self.iceberg_source.is_some() {
5207 len += 1;
5208 }
5209 if self.if_not_exists {
5210 len += 1;
5211 }
5212 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
5213 if let Some(v) = self.table_info.as_ref() {
5214 struct_ser.serialize_field("tableInfo", v)?;
5215 }
5216 if let Some(v) = self.sink_info.as_ref() {
5217 struct_ser.serialize_field("sinkInfo", v)?;
5218 }
5219 if let Some(v) = self.iceberg_source.as_ref() {
5220 struct_ser.serialize_field("icebergSource", v)?;
5221 }
5222 if self.if_not_exists {
5223 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5224 }
5225 struct_ser.end()
5226 }
5227}
5228impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
5229 #[allow(deprecated)]
5230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5231 where
5232 D: serde::Deserializer<'de>,
5233 {
5234 const FIELDS: &[&str] = &[
5235 "table_info",
5236 "tableInfo",
5237 "sink_info",
5238 "sinkInfo",
5239 "iceberg_source",
5240 "icebergSource",
5241 "if_not_exists",
5242 "ifNotExists",
5243 ];
5244
5245 #[allow(clippy::enum_variant_names)]
5246 enum GeneratedField {
5247 TableInfo,
5248 SinkInfo,
5249 IcebergSource,
5250 IfNotExists,
5251 }
5252 impl<'de> serde::Deserialize<'de> for GeneratedField {
5253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5254 where
5255 D: serde::Deserializer<'de>,
5256 {
5257 struct GeneratedVisitor;
5258
5259 impl serde::de::Visitor<'_> for GeneratedVisitor {
5260 type Value = GeneratedField;
5261
5262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5263 write!(formatter, "expected one of: {:?}", &FIELDS)
5264 }
5265
5266 #[allow(unused_variables)]
5267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5268 where
5269 E: serde::de::Error,
5270 {
5271 match value {
5272 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
5273 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
5274 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
5275 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5276 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5277 }
5278 }
5279 }
5280 deserializer.deserialize_identifier(GeneratedVisitor)
5281 }
5282 }
5283 struct GeneratedVisitor;
5284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5285 type Value = CreateIcebergTableRequest;
5286
5287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5288 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
5289 }
5290
5291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
5292 where
5293 V: serde::de::MapAccess<'de>,
5294 {
5295 let mut table_info__ = None;
5296 let mut sink_info__ = None;
5297 let mut iceberg_source__ = None;
5298 let mut if_not_exists__ = None;
5299 while let Some(k) = map_.next_key()? {
5300 match k {
5301 GeneratedField::TableInfo => {
5302 if table_info__.is_some() {
5303 return Err(serde::de::Error::duplicate_field("tableInfo"));
5304 }
5305 table_info__ = map_.next_value()?;
5306 }
5307 GeneratedField::SinkInfo => {
5308 if sink_info__.is_some() {
5309 return Err(serde::de::Error::duplicate_field("sinkInfo"));
5310 }
5311 sink_info__ = map_.next_value()?;
5312 }
5313 GeneratedField::IcebergSource => {
5314 if iceberg_source__.is_some() {
5315 return Err(serde::de::Error::duplicate_field("icebergSource"));
5316 }
5317 iceberg_source__ = map_.next_value()?;
5318 }
5319 GeneratedField::IfNotExists => {
5320 if if_not_exists__.is_some() {
5321 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5322 }
5323 if_not_exists__ = Some(map_.next_value()?);
5324 }
5325 }
5326 }
5327 Ok(CreateIcebergTableRequest {
5328 table_info: table_info__,
5329 sink_info: sink_info__,
5330 iceberg_source: iceberg_source__,
5331 if_not_exists: if_not_exists__.unwrap_or_default(),
5332 })
5333 }
5334 }
5335 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
5336 }
5337}
5338impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
5339 #[allow(deprecated)]
5340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5341 where
5342 S: serde::Serializer,
5343 {
5344 use serde::ser::SerializeStruct;
5345 let mut len = 0;
5346 if self.sink.is_some() {
5347 len += 1;
5348 }
5349 if self.fragment_graph.is_some() {
5350 len += 1;
5351 }
5352 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
5353 if let Some(v) = self.sink.as_ref() {
5354 struct_ser.serialize_field("sink", v)?;
5355 }
5356 if let Some(v) = self.fragment_graph.as_ref() {
5357 struct_ser.serialize_field("fragmentGraph", v)?;
5358 }
5359 struct_ser.end()
5360 }
5361}
5362impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
5363 #[allow(deprecated)]
5364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5365 where
5366 D: serde::Deserializer<'de>,
5367 {
5368 const FIELDS: &[&str] = &[
5369 "sink",
5370 "fragment_graph",
5371 "fragmentGraph",
5372 ];
5373
5374 #[allow(clippy::enum_variant_names)]
5375 enum GeneratedField {
5376 Sink,
5377 FragmentGraph,
5378 }
5379 impl<'de> serde::Deserialize<'de> for GeneratedField {
5380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5381 where
5382 D: serde::Deserializer<'de>,
5383 {
5384 struct GeneratedVisitor;
5385
5386 impl serde::de::Visitor<'_> for GeneratedVisitor {
5387 type Value = GeneratedField;
5388
5389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5390 write!(formatter, "expected one of: {:?}", &FIELDS)
5391 }
5392
5393 #[allow(unused_variables)]
5394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5395 where
5396 E: serde::de::Error,
5397 {
5398 match value {
5399 "sink" => Ok(GeneratedField::Sink),
5400 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5402 }
5403 }
5404 }
5405 deserializer.deserialize_identifier(GeneratedVisitor)
5406 }
5407 }
5408 struct GeneratedVisitor;
5409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5410 type Value = create_iceberg_table_request::SinkJobInfo;
5411
5412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5413 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
5414 }
5415
5416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
5417 where
5418 V: serde::de::MapAccess<'de>,
5419 {
5420 let mut sink__ = None;
5421 let mut fragment_graph__ = None;
5422 while let Some(k) = map_.next_key()? {
5423 match k {
5424 GeneratedField::Sink => {
5425 if sink__.is_some() {
5426 return Err(serde::de::Error::duplicate_field("sink"));
5427 }
5428 sink__ = map_.next_value()?;
5429 }
5430 GeneratedField::FragmentGraph => {
5431 if fragment_graph__.is_some() {
5432 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5433 }
5434 fragment_graph__ = map_.next_value()?;
5435 }
5436 }
5437 }
5438 Ok(create_iceberg_table_request::SinkJobInfo {
5439 sink: sink__,
5440 fragment_graph: fragment_graph__,
5441 })
5442 }
5443 }
5444 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
5445 }
5446}
5447impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
5448 #[allow(deprecated)]
5449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5450 where
5451 S: serde::Serializer,
5452 {
5453 use serde::ser::SerializeStruct;
5454 let mut len = 0;
5455 if self.source.is_some() {
5456 len += 1;
5457 }
5458 if self.table.is_some() {
5459 len += 1;
5460 }
5461 if self.fragment_graph.is_some() {
5462 len += 1;
5463 }
5464 if self.job_type != 0 {
5465 len += 1;
5466 }
5467 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
5468 if let Some(v) = self.source.as_ref() {
5469 struct_ser.serialize_field("source", v)?;
5470 }
5471 if let Some(v) = self.table.as_ref() {
5472 struct_ser.serialize_field("table", v)?;
5473 }
5474 if let Some(v) = self.fragment_graph.as_ref() {
5475 struct_ser.serialize_field("fragmentGraph", v)?;
5476 }
5477 if self.job_type != 0 {
5478 let v = TableJobType::try_from(self.job_type)
5479 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
5480 struct_ser.serialize_field("jobType", &v)?;
5481 }
5482 struct_ser.end()
5483 }
5484}
5485impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
5486 #[allow(deprecated)]
5487 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5488 where
5489 D: serde::Deserializer<'de>,
5490 {
5491 const FIELDS: &[&str] = &[
5492 "source",
5493 "table",
5494 "fragment_graph",
5495 "fragmentGraph",
5496 "job_type",
5497 "jobType",
5498 ];
5499
5500 #[allow(clippy::enum_variant_names)]
5501 enum GeneratedField {
5502 Source,
5503 Table,
5504 FragmentGraph,
5505 JobType,
5506 }
5507 impl<'de> serde::Deserialize<'de> for GeneratedField {
5508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5509 where
5510 D: serde::Deserializer<'de>,
5511 {
5512 struct GeneratedVisitor;
5513
5514 impl serde::de::Visitor<'_> for GeneratedVisitor {
5515 type Value = GeneratedField;
5516
5517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5518 write!(formatter, "expected one of: {:?}", &FIELDS)
5519 }
5520
5521 #[allow(unused_variables)]
5522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5523 where
5524 E: serde::de::Error,
5525 {
5526 match value {
5527 "source" => Ok(GeneratedField::Source),
5528 "table" => Ok(GeneratedField::Table),
5529 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5530 "jobType" | "job_type" => Ok(GeneratedField::JobType),
5531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5532 }
5533 }
5534 }
5535 deserializer.deserialize_identifier(GeneratedVisitor)
5536 }
5537 }
5538 struct GeneratedVisitor;
5539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5540 type Value = create_iceberg_table_request::TableJobInfo;
5541
5542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5543 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
5544 }
5545
5546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
5547 where
5548 V: serde::de::MapAccess<'de>,
5549 {
5550 let mut source__ = None;
5551 let mut table__ = None;
5552 let mut fragment_graph__ = None;
5553 let mut job_type__ = None;
5554 while let Some(k) = map_.next_key()? {
5555 match k {
5556 GeneratedField::Source => {
5557 if source__.is_some() {
5558 return Err(serde::de::Error::duplicate_field("source"));
5559 }
5560 source__ = map_.next_value()?;
5561 }
5562 GeneratedField::Table => {
5563 if table__.is_some() {
5564 return Err(serde::de::Error::duplicate_field("table"));
5565 }
5566 table__ = map_.next_value()?;
5567 }
5568 GeneratedField::FragmentGraph => {
5569 if fragment_graph__.is_some() {
5570 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5571 }
5572 fragment_graph__ = map_.next_value()?;
5573 }
5574 GeneratedField::JobType => {
5575 if job_type__.is_some() {
5576 return Err(serde::de::Error::duplicate_field("jobType"));
5577 }
5578 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
5579 }
5580 }
5581 }
5582 Ok(create_iceberg_table_request::TableJobInfo {
5583 source: source__,
5584 table: table__,
5585 fragment_graph: fragment_graph__,
5586 job_type: job_type__.unwrap_or_default(),
5587 })
5588 }
5589 }
5590 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
5591 }
5592}
5593impl serde::Serialize for CreateIcebergTableResponse {
5594 #[allow(deprecated)]
5595 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5596 where
5597 S: serde::Serializer,
5598 {
5599 use serde::ser::SerializeStruct;
5600 let mut len = 0;
5601 if self.status.is_some() {
5602 len += 1;
5603 }
5604 if self.version.is_some() {
5605 len += 1;
5606 }
5607 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
5608 if let Some(v) = self.status.as_ref() {
5609 struct_ser.serialize_field("status", v)?;
5610 }
5611 if let Some(v) = self.version.as_ref() {
5612 struct_ser.serialize_field("version", v)?;
5613 }
5614 struct_ser.end()
5615 }
5616}
5617impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
5618 #[allow(deprecated)]
5619 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5620 where
5621 D: serde::Deserializer<'de>,
5622 {
5623 const FIELDS: &[&str] = &[
5624 "status",
5625 "version",
5626 ];
5627
5628 #[allow(clippy::enum_variant_names)]
5629 enum GeneratedField {
5630 Status,
5631 Version,
5632 }
5633 impl<'de> serde::Deserialize<'de> for GeneratedField {
5634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5635 where
5636 D: serde::Deserializer<'de>,
5637 {
5638 struct GeneratedVisitor;
5639
5640 impl serde::de::Visitor<'_> for GeneratedVisitor {
5641 type Value = GeneratedField;
5642
5643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5644 write!(formatter, "expected one of: {:?}", &FIELDS)
5645 }
5646
5647 #[allow(unused_variables)]
5648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5649 where
5650 E: serde::de::Error,
5651 {
5652 match value {
5653 "status" => Ok(GeneratedField::Status),
5654 "version" => Ok(GeneratedField::Version),
5655 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5656 }
5657 }
5658 }
5659 deserializer.deserialize_identifier(GeneratedVisitor)
5660 }
5661 }
5662 struct GeneratedVisitor;
5663 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5664 type Value = CreateIcebergTableResponse;
5665
5666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5667 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
5668 }
5669
5670 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
5671 where
5672 V: serde::de::MapAccess<'de>,
5673 {
5674 let mut status__ = None;
5675 let mut version__ = None;
5676 while let Some(k) = map_.next_key()? {
5677 match k {
5678 GeneratedField::Status => {
5679 if status__.is_some() {
5680 return Err(serde::de::Error::duplicate_field("status"));
5681 }
5682 status__ = map_.next_value()?;
5683 }
5684 GeneratedField::Version => {
5685 if version__.is_some() {
5686 return Err(serde::de::Error::duplicate_field("version"));
5687 }
5688 version__ = map_.next_value()?;
5689 }
5690 }
5691 }
5692 Ok(CreateIcebergTableResponse {
5693 status: status__,
5694 version: version__,
5695 })
5696 }
5697 }
5698 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
5699 }
5700}
5701impl serde::Serialize for CreateIndexRequest {
5702 #[allow(deprecated)]
5703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5704 where
5705 S: serde::Serializer,
5706 {
5707 use serde::ser::SerializeStruct;
5708 let mut len = 0;
5709 if self.index.is_some() {
5710 len += 1;
5711 }
5712 if self.index_table.is_some() {
5713 len += 1;
5714 }
5715 if self.fragment_graph.is_some() {
5716 len += 1;
5717 }
5718 if self.if_not_exists {
5719 len += 1;
5720 }
5721 if self.resource_type.is_some() {
5722 len += 1;
5723 }
5724 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
5725 if let Some(v) = self.index.as_ref() {
5726 struct_ser.serialize_field("index", v)?;
5727 }
5728 if let Some(v) = self.index_table.as_ref() {
5729 struct_ser.serialize_field("indexTable", v)?;
5730 }
5731 if let Some(v) = self.fragment_graph.as_ref() {
5732 struct_ser.serialize_field("fragmentGraph", v)?;
5733 }
5734 if self.if_not_exists {
5735 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5736 }
5737 if let Some(v) = self.resource_type.as_ref() {
5738 struct_ser.serialize_field("resourceType", v)?;
5739 }
5740 struct_ser.end()
5741 }
5742}
5743impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
5744 #[allow(deprecated)]
5745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5746 where
5747 D: serde::Deserializer<'de>,
5748 {
5749 const FIELDS: &[&str] = &[
5750 "index",
5751 "index_table",
5752 "indexTable",
5753 "fragment_graph",
5754 "fragmentGraph",
5755 "if_not_exists",
5756 "ifNotExists",
5757 "resource_type",
5758 "resourceType",
5759 ];
5760
5761 #[allow(clippy::enum_variant_names)]
5762 enum GeneratedField {
5763 Index,
5764 IndexTable,
5765 FragmentGraph,
5766 IfNotExists,
5767 ResourceType,
5768 }
5769 impl<'de> serde::Deserialize<'de> for GeneratedField {
5770 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5771 where
5772 D: serde::Deserializer<'de>,
5773 {
5774 struct GeneratedVisitor;
5775
5776 impl serde::de::Visitor<'_> for GeneratedVisitor {
5777 type Value = GeneratedField;
5778
5779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5780 write!(formatter, "expected one of: {:?}", &FIELDS)
5781 }
5782
5783 #[allow(unused_variables)]
5784 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5785 where
5786 E: serde::de::Error,
5787 {
5788 match value {
5789 "index" => Ok(GeneratedField::Index),
5790 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
5791 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5792 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5793 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
5794 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5795 }
5796 }
5797 }
5798 deserializer.deserialize_identifier(GeneratedVisitor)
5799 }
5800 }
5801 struct GeneratedVisitor;
5802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5803 type Value = CreateIndexRequest;
5804
5805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5806 formatter.write_str("struct ddl_service.CreateIndexRequest")
5807 }
5808
5809 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
5810 where
5811 V: serde::de::MapAccess<'de>,
5812 {
5813 let mut index__ = None;
5814 let mut index_table__ = None;
5815 let mut fragment_graph__ = None;
5816 let mut if_not_exists__ = None;
5817 let mut resource_type__ = None;
5818 while let Some(k) = map_.next_key()? {
5819 match k {
5820 GeneratedField::Index => {
5821 if index__.is_some() {
5822 return Err(serde::de::Error::duplicate_field("index"));
5823 }
5824 index__ = map_.next_value()?;
5825 }
5826 GeneratedField::IndexTable => {
5827 if index_table__.is_some() {
5828 return Err(serde::de::Error::duplicate_field("indexTable"));
5829 }
5830 index_table__ = map_.next_value()?;
5831 }
5832 GeneratedField::FragmentGraph => {
5833 if fragment_graph__.is_some() {
5834 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5835 }
5836 fragment_graph__ = map_.next_value()?;
5837 }
5838 GeneratedField::IfNotExists => {
5839 if if_not_exists__.is_some() {
5840 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5841 }
5842 if_not_exists__ = Some(map_.next_value()?);
5843 }
5844 GeneratedField::ResourceType => {
5845 if resource_type__.is_some() {
5846 return Err(serde::de::Error::duplicate_field("resourceType"));
5847 }
5848 resource_type__ = map_.next_value()?;
5849 }
5850 }
5851 }
5852 Ok(CreateIndexRequest {
5853 index: index__,
5854 index_table: index_table__,
5855 fragment_graph: fragment_graph__,
5856 if_not_exists: if_not_exists__.unwrap_or_default(),
5857 resource_type: resource_type__,
5858 })
5859 }
5860 }
5861 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
5862 }
5863}
5864impl serde::Serialize for CreateIndexResponse {
5865 #[allow(deprecated)]
5866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5867 where
5868 S: serde::Serializer,
5869 {
5870 use serde::ser::SerializeStruct;
5871 let mut len = 0;
5872 if self.status.is_some() {
5873 len += 1;
5874 }
5875 if self.version.is_some() {
5876 len += 1;
5877 }
5878 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
5879 if let Some(v) = self.status.as_ref() {
5880 struct_ser.serialize_field("status", v)?;
5881 }
5882 if let Some(v) = self.version.as_ref() {
5883 struct_ser.serialize_field("version", v)?;
5884 }
5885 struct_ser.end()
5886 }
5887}
5888impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
5889 #[allow(deprecated)]
5890 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5891 where
5892 D: serde::Deserializer<'de>,
5893 {
5894 const FIELDS: &[&str] = &[
5895 "status",
5896 "version",
5897 ];
5898
5899 #[allow(clippy::enum_variant_names)]
5900 enum GeneratedField {
5901 Status,
5902 Version,
5903 }
5904 impl<'de> serde::Deserialize<'de> for GeneratedField {
5905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5906 where
5907 D: serde::Deserializer<'de>,
5908 {
5909 struct GeneratedVisitor;
5910
5911 impl serde::de::Visitor<'_> for GeneratedVisitor {
5912 type Value = GeneratedField;
5913
5914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5915 write!(formatter, "expected one of: {:?}", &FIELDS)
5916 }
5917
5918 #[allow(unused_variables)]
5919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5920 where
5921 E: serde::de::Error,
5922 {
5923 match value {
5924 "status" => Ok(GeneratedField::Status),
5925 "version" => Ok(GeneratedField::Version),
5926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5927 }
5928 }
5929 }
5930 deserializer.deserialize_identifier(GeneratedVisitor)
5931 }
5932 }
5933 struct GeneratedVisitor;
5934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5935 type Value = CreateIndexResponse;
5936
5937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5938 formatter.write_str("struct ddl_service.CreateIndexResponse")
5939 }
5940
5941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
5942 where
5943 V: serde::de::MapAccess<'de>,
5944 {
5945 let mut status__ = None;
5946 let mut version__ = None;
5947 while let Some(k) = map_.next_key()? {
5948 match k {
5949 GeneratedField::Status => {
5950 if status__.is_some() {
5951 return Err(serde::de::Error::duplicate_field("status"));
5952 }
5953 status__ = map_.next_value()?;
5954 }
5955 GeneratedField::Version => {
5956 if version__.is_some() {
5957 return Err(serde::de::Error::duplicate_field("version"));
5958 }
5959 version__ = map_.next_value()?;
5960 }
5961 }
5962 }
5963 Ok(CreateIndexResponse {
5964 status: status__,
5965 version: version__,
5966 })
5967 }
5968 }
5969 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
5970 }
5971}
5972impl serde::Serialize for CreateMaterializedViewRequest {
5973 #[allow(deprecated)]
5974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5975 where
5976 S: serde::Serializer,
5977 {
5978 use serde::ser::SerializeStruct;
5979 let mut len = 0;
5980 if self.materialized_view.is_some() {
5981 len += 1;
5982 }
5983 if self.fragment_graph.is_some() {
5984 len += 1;
5985 }
5986 if self.resource_type.is_some() {
5987 len += 1;
5988 }
5989 if !self.dependencies.is_empty() {
5990 len += 1;
5991 }
5992 if self.if_not_exists {
5993 len += 1;
5994 }
5995 if self.refresh_interval_sec.is_some() {
5996 len += 1;
5997 }
5998 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
5999 if let Some(v) = self.materialized_view.as_ref() {
6000 struct_ser.serialize_field("materializedView", v)?;
6001 }
6002 if let Some(v) = self.fragment_graph.as_ref() {
6003 struct_ser.serialize_field("fragmentGraph", v)?;
6004 }
6005 if let Some(v) = self.resource_type.as_ref() {
6006 struct_ser.serialize_field("resourceType", v)?;
6007 }
6008 if !self.dependencies.is_empty() {
6009 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6010 }
6011 if self.if_not_exists {
6012 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6013 }
6014 if let Some(v) = self.refresh_interval_sec.as_ref() {
6015 #[allow(clippy::needless_borrow)]
6016 #[allow(clippy::needless_borrows_for_generic_args)]
6017 struct_ser.serialize_field("refreshIntervalSec", ToString::to_string(&v).as_str())?;
6018 }
6019 struct_ser.end()
6020 }
6021}
6022impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
6023 #[allow(deprecated)]
6024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6025 where
6026 D: serde::Deserializer<'de>,
6027 {
6028 const FIELDS: &[&str] = &[
6029 "materialized_view",
6030 "materializedView",
6031 "fragment_graph",
6032 "fragmentGraph",
6033 "resource_type",
6034 "resourceType",
6035 "dependencies",
6036 "if_not_exists",
6037 "ifNotExists",
6038 "refresh_interval_sec",
6039 "refreshIntervalSec",
6040 ];
6041
6042 #[allow(clippy::enum_variant_names)]
6043 enum GeneratedField {
6044 MaterializedView,
6045 FragmentGraph,
6046 ResourceType,
6047 Dependencies,
6048 IfNotExists,
6049 RefreshIntervalSec,
6050 }
6051 impl<'de> serde::Deserialize<'de> for GeneratedField {
6052 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6053 where
6054 D: serde::Deserializer<'de>,
6055 {
6056 struct GeneratedVisitor;
6057
6058 impl serde::de::Visitor<'_> for GeneratedVisitor {
6059 type Value = GeneratedField;
6060
6061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6062 write!(formatter, "expected one of: {:?}", &FIELDS)
6063 }
6064
6065 #[allow(unused_variables)]
6066 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6067 where
6068 E: serde::de::Error,
6069 {
6070 match value {
6071 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
6072 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6073 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
6074 "dependencies" => Ok(GeneratedField::Dependencies),
6075 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6076 "refreshIntervalSec" | "refresh_interval_sec" => Ok(GeneratedField::RefreshIntervalSec),
6077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6078 }
6079 }
6080 }
6081 deserializer.deserialize_identifier(GeneratedVisitor)
6082 }
6083 }
6084 struct GeneratedVisitor;
6085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6086 type Value = CreateMaterializedViewRequest;
6087
6088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6089 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
6090 }
6091
6092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
6093 where
6094 V: serde::de::MapAccess<'de>,
6095 {
6096 let mut materialized_view__ = None;
6097 let mut fragment_graph__ = None;
6098 let mut resource_type__ = None;
6099 let mut dependencies__ = None;
6100 let mut if_not_exists__ = None;
6101 let mut refresh_interval_sec__ = None;
6102 while let Some(k) = map_.next_key()? {
6103 match k {
6104 GeneratedField::MaterializedView => {
6105 if materialized_view__.is_some() {
6106 return Err(serde::de::Error::duplicate_field("materializedView"));
6107 }
6108 materialized_view__ = map_.next_value()?;
6109 }
6110 GeneratedField::FragmentGraph => {
6111 if fragment_graph__.is_some() {
6112 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6113 }
6114 fragment_graph__ = map_.next_value()?;
6115 }
6116 GeneratedField::ResourceType => {
6117 if resource_type__.is_some() {
6118 return Err(serde::de::Error::duplicate_field("resourceType"));
6119 }
6120 resource_type__ = map_.next_value()?;
6121 }
6122 GeneratedField::Dependencies => {
6123 if dependencies__.is_some() {
6124 return Err(serde::de::Error::duplicate_field("dependencies"));
6125 }
6126 dependencies__ =
6127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6128 .into_iter().map(|x| x.0).collect())
6129 ;
6130 }
6131 GeneratedField::IfNotExists => {
6132 if if_not_exists__.is_some() {
6133 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6134 }
6135 if_not_exists__ = Some(map_.next_value()?);
6136 }
6137 GeneratedField::RefreshIntervalSec => {
6138 if refresh_interval_sec__.is_some() {
6139 return Err(serde::de::Error::duplicate_field("refreshIntervalSec"));
6140 }
6141 refresh_interval_sec__ =
6142 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6143 ;
6144 }
6145 }
6146 }
6147 Ok(CreateMaterializedViewRequest {
6148 materialized_view: materialized_view__,
6149 fragment_graph: fragment_graph__,
6150 resource_type: resource_type__,
6151 dependencies: dependencies__.unwrap_or_default(),
6152 if_not_exists: if_not_exists__.unwrap_or_default(),
6153 refresh_interval_sec: refresh_interval_sec__,
6154 })
6155 }
6156 }
6157 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
6158 }
6159}
6160impl serde::Serialize for CreateMaterializedViewResponse {
6161 #[allow(deprecated)]
6162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6163 where
6164 S: serde::Serializer,
6165 {
6166 use serde::ser::SerializeStruct;
6167 let mut len = 0;
6168 if self.status.is_some() {
6169 len += 1;
6170 }
6171 if self.version.is_some() {
6172 len += 1;
6173 }
6174 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
6175 if let Some(v) = self.status.as_ref() {
6176 struct_ser.serialize_field("status", v)?;
6177 }
6178 if let Some(v) = self.version.as_ref() {
6179 struct_ser.serialize_field("version", v)?;
6180 }
6181 struct_ser.end()
6182 }
6183}
6184impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
6185 #[allow(deprecated)]
6186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6187 where
6188 D: serde::Deserializer<'de>,
6189 {
6190 const FIELDS: &[&str] = &[
6191 "status",
6192 "version",
6193 ];
6194
6195 #[allow(clippy::enum_variant_names)]
6196 enum GeneratedField {
6197 Status,
6198 Version,
6199 }
6200 impl<'de> serde::Deserialize<'de> for GeneratedField {
6201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6202 where
6203 D: serde::Deserializer<'de>,
6204 {
6205 struct GeneratedVisitor;
6206
6207 impl serde::de::Visitor<'_> for GeneratedVisitor {
6208 type Value = GeneratedField;
6209
6210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6211 write!(formatter, "expected one of: {:?}", &FIELDS)
6212 }
6213
6214 #[allow(unused_variables)]
6215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6216 where
6217 E: serde::de::Error,
6218 {
6219 match value {
6220 "status" => Ok(GeneratedField::Status),
6221 "version" => Ok(GeneratedField::Version),
6222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6223 }
6224 }
6225 }
6226 deserializer.deserialize_identifier(GeneratedVisitor)
6227 }
6228 }
6229 struct GeneratedVisitor;
6230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6231 type Value = CreateMaterializedViewResponse;
6232
6233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6234 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
6235 }
6236
6237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
6238 where
6239 V: serde::de::MapAccess<'de>,
6240 {
6241 let mut status__ = None;
6242 let mut version__ = None;
6243 while let Some(k) = map_.next_key()? {
6244 match k {
6245 GeneratedField::Status => {
6246 if status__.is_some() {
6247 return Err(serde::de::Error::duplicate_field("status"));
6248 }
6249 status__ = map_.next_value()?;
6250 }
6251 GeneratedField::Version => {
6252 if version__.is_some() {
6253 return Err(serde::de::Error::duplicate_field("version"));
6254 }
6255 version__ = map_.next_value()?;
6256 }
6257 }
6258 }
6259 Ok(CreateMaterializedViewResponse {
6260 status: status__,
6261 version: version__,
6262 })
6263 }
6264 }
6265 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
6266 }
6267}
6268impl serde::Serialize for CreateSchemaRequest {
6269 #[allow(deprecated)]
6270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6271 where
6272 S: serde::Serializer,
6273 {
6274 use serde::ser::SerializeStruct;
6275 let mut len = 0;
6276 if self.schema.is_some() {
6277 len += 1;
6278 }
6279 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
6280 if let Some(v) = self.schema.as_ref() {
6281 struct_ser.serialize_field("schema", v)?;
6282 }
6283 struct_ser.end()
6284 }
6285}
6286impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
6287 #[allow(deprecated)]
6288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6289 where
6290 D: serde::Deserializer<'de>,
6291 {
6292 const FIELDS: &[&str] = &[
6293 "schema",
6294 ];
6295
6296 #[allow(clippy::enum_variant_names)]
6297 enum GeneratedField {
6298 Schema,
6299 }
6300 impl<'de> serde::Deserialize<'de> for GeneratedField {
6301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6302 where
6303 D: serde::Deserializer<'de>,
6304 {
6305 struct GeneratedVisitor;
6306
6307 impl serde::de::Visitor<'_> for GeneratedVisitor {
6308 type Value = GeneratedField;
6309
6310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6311 write!(formatter, "expected one of: {:?}", &FIELDS)
6312 }
6313
6314 #[allow(unused_variables)]
6315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6316 where
6317 E: serde::de::Error,
6318 {
6319 match value {
6320 "schema" => Ok(GeneratedField::Schema),
6321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6322 }
6323 }
6324 }
6325 deserializer.deserialize_identifier(GeneratedVisitor)
6326 }
6327 }
6328 struct GeneratedVisitor;
6329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6330 type Value = CreateSchemaRequest;
6331
6332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6333 formatter.write_str("struct ddl_service.CreateSchemaRequest")
6334 }
6335
6336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
6337 where
6338 V: serde::de::MapAccess<'de>,
6339 {
6340 let mut schema__ = None;
6341 while let Some(k) = map_.next_key()? {
6342 match k {
6343 GeneratedField::Schema => {
6344 if schema__.is_some() {
6345 return Err(serde::de::Error::duplicate_field("schema"));
6346 }
6347 schema__ = map_.next_value()?;
6348 }
6349 }
6350 }
6351 Ok(CreateSchemaRequest {
6352 schema: schema__,
6353 })
6354 }
6355 }
6356 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
6357 }
6358}
6359impl serde::Serialize for CreateSchemaResponse {
6360 #[allow(deprecated)]
6361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6362 where
6363 S: serde::Serializer,
6364 {
6365 use serde::ser::SerializeStruct;
6366 let mut len = 0;
6367 if self.status.is_some() {
6368 len += 1;
6369 }
6370 if self.version.is_some() {
6371 len += 1;
6372 }
6373 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
6374 if let Some(v) = self.status.as_ref() {
6375 struct_ser.serialize_field("status", v)?;
6376 }
6377 if let Some(v) = self.version.as_ref() {
6378 struct_ser.serialize_field("version", v)?;
6379 }
6380 struct_ser.end()
6381 }
6382}
6383impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
6384 #[allow(deprecated)]
6385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6386 where
6387 D: serde::Deserializer<'de>,
6388 {
6389 const FIELDS: &[&str] = &[
6390 "status",
6391 "version",
6392 ];
6393
6394 #[allow(clippy::enum_variant_names)]
6395 enum GeneratedField {
6396 Status,
6397 Version,
6398 }
6399 impl<'de> serde::Deserialize<'de> for GeneratedField {
6400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6401 where
6402 D: serde::Deserializer<'de>,
6403 {
6404 struct GeneratedVisitor;
6405
6406 impl serde::de::Visitor<'_> for GeneratedVisitor {
6407 type Value = GeneratedField;
6408
6409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6410 write!(formatter, "expected one of: {:?}", &FIELDS)
6411 }
6412
6413 #[allow(unused_variables)]
6414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6415 where
6416 E: serde::de::Error,
6417 {
6418 match value {
6419 "status" => Ok(GeneratedField::Status),
6420 "version" => Ok(GeneratedField::Version),
6421 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6422 }
6423 }
6424 }
6425 deserializer.deserialize_identifier(GeneratedVisitor)
6426 }
6427 }
6428 struct GeneratedVisitor;
6429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6430 type Value = CreateSchemaResponse;
6431
6432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6433 formatter.write_str("struct ddl_service.CreateSchemaResponse")
6434 }
6435
6436 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
6437 where
6438 V: serde::de::MapAccess<'de>,
6439 {
6440 let mut status__ = None;
6441 let mut version__ = None;
6442 while let Some(k) = map_.next_key()? {
6443 match k {
6444 GeneratedField::Status => {
6445 if status__.is_some() {
6446 return Err(serde::de::Error::duplicate_field("status"));
6447 }
6448 status__ = map_.next_value()?;
6449 }
6450 GeneratedField::Version => {
6451 if version__.is_some() {
6452 return Err(serde::de::Error::duplicate_field("version"));
6453 }
6454 version__ = map_.next_value()?;
6455 }
6456 }
6457 }
6458 Ok(CreateSchemaResponse {
6459 status: status__,
6460 version: version__,
6461 })
6462 }
6463 }
6464 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
6465 }
6466}
6467impl serde::Serialize for CreateSecretRequest {
6468 #[allow(deprecated)]
6469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6470 where
6471 S: serde::Serializer,
6472 {
6473 use serde::ser::SerializeStruct;
6474 let mut len = 0;
6475 if !self.name.is_empty() {
6476 len += 1;
6477 }
6478 if !self.value.is_empty() {
6479 len += 1;
6480 }
6481 if self.database_id != 0 {
6482 len += 1;
6483 }
6484 if self.schema_id != 0 {
6485 len += 1;
6486 }
6487 if self.owner_id != 0 {
6488 len += 1;
6489 }
6490 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
6491 if !self.name.is_empty() {
6492 struct_ser.serialize_field("name", &self.name)?;
6493 }
6494 if !self.value.is_empty() {
6495 #[allow(clippy::needless_borrow)]
6496 #[allow(clippy::needless_borrows_for_generic_args)]
6497 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
6498 }
6499 if self.database_id != 0 {
6500 struct_ser.serialize_field("databaseId", &self.database_id)?;
6501 }
6502 if self.schema_id != 0 {
6503 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6504 }
6505 if self.owner_id != 0 {
6506 struct_ser.serialize_field("ownerId", &self.owner_id)?;
6507 }
6508 struct_ser.end()
6509 }
6510}
6511impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
6512 #[allow(deprecated)]
6513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6514 where
6515 D: serde::Deserializer<'de>,
6516 {
6517 const FIELDS: &[&str] = &[
6518 "name",
6519 "value",
6520 "database_id",
6521 "databaseId",
6522 "schema_id",
6523 "schemaId",
6524 "owner_id",
6525 "ownerId",
6526 ];
6527
6528 #[allow(clippy::enum_variant_names)]
6529 enum GeneratedField {
6530 Name,
6531 Value,
6532 DatabaseId,
6533 SchemaId,
6534 OwnerId,
6535 }
6536 impl<'de> serde::Deserialize<'de> for GeneratedField {
6537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6538 where
6539 D: serde::Deserializer<'de>,
6540 {
6541 struct GeneratedVisitor;
6542
6543 impl serde::de::Visitor<'_> for GeneratedVisitor {
6544 type Value = GeneratedField;
6545
6546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6547 write!(formatter, "expected one of: {:?}", &FIELDS)
6548 }
6549
6550 #[allow(unused_variables)]
6551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6552 where
6553 E: serde::de::Error,
6554 {
6555 match value {
6556 "name" => Ok(GeneratedField::Name),
6557 "value" => Ok(GeneratedField::Value),
6558 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6559 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6560 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
6561 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6562 }
6563 }
6564 }
6565 deserializer.deserialize_identifier(GeneratedVisitor)
6566 }
6567 }
6568 struct GeneratedVisitor;
6569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6570 type Value = CreateSecretRequest;
6571
6572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6573 formatter.write_str("struct ddl_service.CreateSecretRequest")
6574 }
6575
6576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
6577 where
6578 V: serde::de::MapAccess<'de>,
6579 {
6580 let mut name__ = None;
6581 let mut value__ = None;
6582 let mut database_id__ = None;
6583 let mut schema_id__ = None;
6584 let mut owner_id__ = None;
6585 while let Some(k) = map_.next_key()? {
6586 match k {
6587 GeneratedField::Name => {
6588 if name__.is_some() {
6589 return Err(serde::de::Error::duplicate_field("name"));
6590 }
6591 name__ = Some(map_.next_value()?);
6592 }
6593 GeneratedField::Value => {
6594 if value__.is_some() {
6595 return Err(serde::de::Error::duplicate_field("value"));
6596 }
6597 value__ =
6598 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
6599 ;
6600 }
6601 GeneratedField::DatabaseId => {
6602 if database_id__.is_some() {
6603 return Err(serde::de::Error::duplicate_field("databaseId"));
6604 }
6605 database_id__ =
6606 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6607 ;
6608 }
6609 GeneratedField::SchemaId => {
6610 if schema_id__.is_some() {
6611 return Err(serde::de::Error::duplicate_field("schemaId"));
6612 }
6613 schema_id__ =
6614 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6615 ;
6616 }
6617 GeneratedField::OwnerId => {
6618 if owner_id__.is_some() {
6619 return Err(serde::de::Error::duplicate_field("ownerId"));
6620 }
6621 owner_id__ =
6622 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6623 ;
6624 }
6625 }
6626 }
6627 Ok(CreateSecretRequest {
6628 name: name__.unwrap_or_default(),
6629 value: value__.unwrap_or_default(),
6630 database_id: database_id__.unwrap_or_default(),
6631 schema_id: schema_id__.unwrap_or_default(),
6632 owner_id: owner_id__.unwrap_or_default(),
6633 })
6634 }
6635 }
6636 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
6637 }
6638}
6639impl serde::Serialize for CreateSecretResponse {
6640 #[allow(deprecated)]
6641 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6642 where
6643 S: serde::Serializer,
6644 {
6645 use serde::ser::SerializeStruct;
6646 let mut len = 0;
6647 if self.version.is_some() {
6648 len += 1;
6649 }
6650 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
6651 if let Some(v) = self.version.as_ref() {
6652 struct_ser.serialize_field("version", v)?;
6653 }
6654 struct_ser.end()
6655 }
6656}
6657impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
6658 #[allow(deprecated)]
6659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6660 where
6661 D: serde::Deserializer<'de>,
6662 {
6663 const FIELDS: &[&str] = &[
6664 "version",
6665 ];
6666
6667 #[allow(clippy::enum_variant_names)]
6668 enum GeneratedField {
6669 Version,
6670 }
6671 impl<'de> serde::Deserialize<'de> for GeneratedField {
6672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6673 where
6674 D: serde::Deserializer<'de>,
6675 {
6676 struct GeneratedVisitor;
6677
6678 impl serde::de::Visitor<'_> for GeneratedVisitor {
6679 type Value = GeneratedField;
6680
6681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6682 write!(formatter, "expected one of: {:?}", &FIELDS)
6683 }
6684
6685 #[allow(unused_variables)]
6686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6687 where
6688 E: serde::de::Error,
6689 {
6690 match value {
6691 "version" => Ok(GeneratedField::Version),
6692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6693 }
6694 }
6695 }
6696 deserializer.deserialize_identifier(GeneratedVisitor)
6697 }
6698 }
6699 struct GeneratedVisitor;
6700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6701 type Value = CreateSecretResponse;
6702
6703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6704 formatter.write_str("struct ddl_service.CreateSecretResponse")
6705 }
6706
6707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
6708 where
6709 V: serde::de::MapAccess<'de>,
6710 {
6711 let mut version__ = None;
6712 while let Some(k) = map_.next_key()? {
6713 match k {
6714 GeneratedField::Version => {
6715 if version__.is_some() {
6716 return Err(serde::de::Error::duplicate_field("version"));
6717 }
6718 version__ = map_.next_value()?;
6719 }
6720 }
6721 }
6722 Ok(CreateSecretResponse {
6723 version: version__,
6724 })
6725 }
6726 }
6727 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
6728 }
6729}
6730impl serde::Serialize for CreateSinkRequest {
6731 #[allow(deprecated)]
6732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6733 where
6734 S: serde::Serializer,
6735 {
6736 use serde::ser::SerializeStruct;
6737 let mut len = 0;
6738 if self.sink.is_some() {
6739 len += 1;
6740 }
6741 if self.fragment_graph.is_some() {
6742 len += 1;
6743 }
6744 if !self.dependencies.is_empty() {
6745 len += 1;
6746 }
6747 if self.if_not_exists {
6748 len += 1;
6749 }
6750 if self.resource_type.is_some() {
6751 len += 1;
6752 }
6753 if self.since_timestamp_epoch.is_some() {
6754 len += 1;
6755 }
6756 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
6757 if let Some(v) = self.sink.as_ref() {
6758 struct_ser.serialize_field("sink", v)?;
6759 }
6760 if let Some(v) = self.fragment_graph.as_ref() {
6761 struct_ser.serialize_field("fragmentGraph", v)?;
6762 }
6763 if !self.dependencies.is_empty() {
6764 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6765 }
6766 if self.if_not_exists {
6767 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6768 }
6769 if let Some(v) = self.resource_type.as_ref() {
6770 struct_ser.serialize_field("resourceType", v)?;
6771 }
6772 if let Some(v) = self.since_timestamp_epoch.as_ref() {
6773 #[allow(clippy::needless_borrow)]
6774 #[allow(clippy::needless_borrows_for_generic_args)]
6775 struct_ser.serialize_field("sinceTimestampEpoch", ToString::to_string(&v).as_str())?;
6776 }
6777 struct_ser.end()
6778 }
6779}
6780impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6781 #[allow(deprecated)]
6782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6783 where
6784 D: serde::Deserializer<'de>,
6785 {
6786 const FIELDS: &[&str] = &[
6787 "sink",
6788 "fragment_graph",
6789 "fragmentGraph",
6790 "dependencies",
6791 "if_not_exists",
6792 "ifNotExists",
6793 "resource_type",
6794 "resourceType",
6795 "since_timestamp_epoch",
6796 "sinceTimestampEpoch",
6797 ];
6798
6799 #[allow(clippy::enum_variant_names)]
6800 enum GeneratedField {
6801 Sink,
6802 FragmentGraph,
6803 Dependencies,
6804 IfNotExists,
6805 ResourceType,
6806 SinceTimestampEpoch,
6807 }
6808 impl<'de> serde::Deserialize<'de> for GeneratedField {
6809 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6810 where
6811 D: serde::Deserializer<'de>,
6812 {
6813 struct GeneratedVisitor;
6814
6815 impl serde::de::Visitor<'_> for GeneratedVisitor {
6816 type Value = GeneratedField;
6817
6818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6819 write!(formatter, "expected one of: {:?}", &FIELDS)
6820 }
6821
6822 #[allow(unused_variables)]
6823 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6824 where
6825 E: serde::de::Error,
6826 {
6827 match value {
6828 "sink" => Ok(GeneratedField::Sink),
6829 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6830 "dependencies" => Ok(GeneratedField::Dependencies),
6831 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6832 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
6833 "sinceTimestampEpoch" | "since_timestamp_epoch" => Ok(GeneratedField::SinceTimestampEpoch),
6834 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6835 }
6836 }
6837 }
6838 deserializer.deserialize_identifier(GeneratedVisitor)
6839 }
6840 }
6841 struct GeneratedVisitor;
6842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6843 type Value = CreateSinkRequest;
6844
6845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6846 formatter.write_str("struct ddl_service.CreateSinkRequest")
6847 }
6848
6849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6850 where
6851 V: serde::de::MapAccess<'de>,
6852 {
6853 let mut sink__ = None;
6854 let mut fragment_graph__ = None;
6855 let mut dependencies__ = None;
6856 let mut if_not_exists__ = None;
6857 let mut resource_type__ = None;
6858 let mut since_timestamp_epoch__ = None;
6859 while let Some(k) = map_.next_key()? {
6860 match k {
6861 GeneratedField::Sink => {
6862 if sink__.is_some() {
6863 return Err(serde::de::Error::duplicate_field("sink"));
6864 }
6865 sink__ = map_.next_value()?;
6866 }
6867 GeneratedField::FragmentGraph => {
6868 if fragment_graph__.is_some() {
6869 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6870 }
6871 fragment_graph__ = map_.next_value()?;
6872 }
6873 GeneratedField::Dependencies => {
6874 if dependencies__.is_some() {
6875 return Err(serde::de::Error::duplicate_field("dependencies"));
6876 }
6877 dependencies__ =
6878 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6879 .into_iter().map(|x| x.0).collect())
6880 ;
6881 }
6882 GeneratedField::IfNotExists => {
6883 if if_not_exists__.is_some() {
6884 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6885 }
6886 if_not_exists__ = Some(map_.next_value()?);
6887 }
6888 GeneratedField::ResourceType => {
6889 if resource_type__.is_some() {
6890 return Err(serde::de::Error::duplicate_field("resourceType"));
6891 }
6892 resource_type__ = map_.next_value()?;
6893 }
6894 GeneratedField::SinceTimestampEpoch => {
6895 if since_timestamp_epoch__.is_some() {
6896 return Err(serde::de::Error::duplicate_field("sinceTimestampEpoch"));
6897 }
6898 since_timestamp_epoch__ =
6899 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6900 ;
6901 }
6902 }
6903 }
6904 Ok(CreateSinkRequest {
6905 sink: sink__,
6906 fragment_graph: fragment_graph__,
6907 dependencies: dependencies__.unwrap_or_default(),
6908 if_not_exists: if_not_exists__.unwrap_or_default(),
6909 resource_type: resource_type__,
6910 since_timestamp_epoch: since_timestamp_epoch__,
6911 })
6912 }
6913 }
6914 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6915 }
6916}
6917impl serde::Serialize for CreateSinkResponse {
6918 #[allow(deprecated)]
6919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6920 where
6921 S: serde::Serializer,
6922 {
6923 use serde::ser::SerializeStruct;
6924 let mut len = 0;
6925 if self.status.is_some() {
6926 len += 1;
6927 }
6928 if self.version.is_some() {
6929 len += 1;
6930 }
6931 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6932 if let Some(v) = self.status.as_ref() {
6933 struct_ser.serialize_field("status", v)?;
6934 }
6935 if let Some(v) = self.version.as_ref() {
6936 struct_ser.serialize_field("version", v)?;
6937 }
6938 struct_ser.end()
6939 }
6940}
6941impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6942 #[allow(deprecated)]
6943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6944 where
6945 D: serde::Deserializer<'de>,
6946 {
6947 const FIELDS: &[&str] = &[
6948 "status",
6949 "version",
6950 ];
6951
6952 #[allow(clippy::enum_variant_names)]
6953 enum GeneratedField {
6954 Status,
6955 Version,
6956 }
6957 impl<'de> serde::Deserialize<'de> for GeneratedField {
6958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6959 where
6960 D: serde::Deserializer<'de>,
6961 {
6962 struct GeneratedVisitor;
6963
6964 impl serde::de::Visitor<'_> for GeneratedVisitor {
6965 type Value = GeneratedField;
6966
6967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6968 write!(formatter, "expected one of: {:?}", &FIELDS)
6969 }
6970
6971 #[allow(unused_variables)]
6972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6973 where
6974 E: serde::de::Error,
6975 {
6976 match value {
6977 "status" => Ok(GeneratedField::Status),
6978 "version" => Ok(GeneratedField::Version),
6979 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6980 }
6981 }
6982 }
6983 deserializer.deserialize_identifier(GeneratedVisitor)
6984 }
6985 }
6986 struct GeneratedVisitor;
6987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6988 type Value = CreateSinkResponse;
6989
6990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6991 formatter.write_str("struct ddl_service.CreateSinkResponse")
6992 }
6993
6994 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6995 where
6996 V: serde::de::MapAccess<'de>,
6997 {
6998 let mut status__ = None;
6999 let mut version__ = None;
7000 while let Some(k) = map_.next_key()? {
7001 match k {
7002 GeneratedField::Status => {
7003 if status__.is_some() {
7004 return Err(serde::de::Error::duplicate_field("status"));
7005 }
7006 status__ = map_.next_value()?;
7007 }
7008 GeneratedField::Version => {
7009 if version__.is_some() {
7010 return Err(serde::de::Error::duplicate_field("version"));
7011 }
7012 version__ = map_.next_value()?;
7013 }
7014 }
7015 }
7016 Ok(CreateSinkResponse {
7017 status: status__,
7018 version: version__,
7019 })
7020 }
7021 }
7022 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
7023 }
7024}
7025impl serde::Serialize for CreateSourceRequest {
7026 #[allow(deprecated)]
7027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7028 where
7029 S: serde::Serializer,
7030 {
7031 use serde::ser::SerializeStruct;
7032 let mut len = 0;
7033 if self.source.is_some() {
7034 len += 1;
7035 }
7036 if self.fragment_graph.is_some() {
7037 len += 1;
7038 }
7039 if self.if_not_exists {
7040 len += 1;
7041 }
7042 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
7043 if let Some(v) = self.source.as_ref() {
7044 struct_ser.serialize_field("source", v)?;
7045 }
7046 if let Some(v) = self.fragment_graph.as_ref() {
7047 struct_ser.serialize_field("fragmentGraph", v)?;
7048 }
7049 if self.if_not_exists {
7050 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7051 }
7052 struct_ser.end()
7053 }
7054}
7055impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
7056 #[allow(deprecated)]
7057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7058 where
7059 D: serde::Deserializer<'de>,
7060 {
7061 const FIELDS: &[&str] = &[
7062 "source",
7063 "fragment_graph",
7064 "fragmentGraph",
7065 "if_not_exists",
7066 "ifNotExists",
7067 ];
7068
7069 #[allow(clippy::enum_variant_names)]
7070 enum GeneratedField {
7071 Source,
7072 FragmentGraph,
7073 IfNotExists,
7074 }
7075 impl<'de> serde::Deserialize<'de> for GeneratedField {
7076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7077 where
7078 D: serde::Deserializer<'de>,
7079 {
7080 struct GeneratedVisitor;
7081
7082 impl serde::de::Visitor<'_> for GeneratedVisitor {
7083 type Value = GeneratedField;
7084
7085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7086 write!(formatter, "expected one of: {:?}", &FIELDS)
7087 }
7088
7089 #[allow(unused_variables)]
7090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7091 where
7092 E: serde::de::Error,
7093 {
7094 match value {
7095 "source" => Ok(GeneratedField::Source),
7096 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7097 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7099 }
7100 }
7101 }
7102 deserializer.deserialize_identifier(GeneratedVisitor)
7103 }
7104 }
7105 struct GeneratedVisitor;
7106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7107 type Value = CreateSourceRequest;
7108
7109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7110 formatter.write_str("struct ddl_service.CreateSourceRequest")
7111 }
7112
7113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
7114 where
7115 V: serde::de::MapAccess<'de>,
7116 {
7117 let mut source__ = None;
7118 let mut fragment_graph__ = None;
7119 let mut if_not_exists__ = None;
7120 while let Some(k) = map_.next_key()? {
7121 match k {
7122 GeneratedField::Source => {
7123 if source__.is_some() {
7124 return Err(serde::de::Error::duplicate_field("source"));
7125 }
7126 source__ = map_.next_value()?;
7127 }
7128 GeneratedField::FragmentGraph => {
7129 if fragment_graph__.is_some() {
7130 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7131 }
7132 fragment_graph__ = map_.next_value()?;
7133 }
7134 GeneratedField::IfNotExists => {
7135 if if_not_exists__.is_some() {
7136 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7137 }
7138 if_not_exists__ = Some(map_.next_value()?);
7139 }
7140 }
7141 }
7142 Ok(CreateSourceRequest {
7143 source: source__,
7144 fragment_graph: fragment_graph__,
7145 if_not_exists: if_not_exists__.unwrap_or_default(),
7146 })
7147 }
7148 }
7149 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
7150 }
7151}
7152impl serde::Serialize for CreateSourceResponse {
7153 #[allow(deprecated)]
7154 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7155 where
7156 S: serde::Serializer,
7157 {
7158 use serde::ser::SerializeStruct;
7159 let mut len = 0;
7160 if self.status.is_some() {
7161 len += 1;
7162 }
7163 if self.version.is_some() {
7164 len += 1;
7165 }
7166 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
7167 if let Some(v) = self.status.as_ref() {
7168 struct_ser.serialize_field("status", v)?;
7169 }
7170 if let Some(v) = self.version.as_ref() {
7171 struct_ser.serialize_field("version", v)?;
7172 }
7173 struct_ser.end()
7174 }
7175}
7176impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
7177 #[allow(deprecated)]
7178 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7179 where
7180 D: serde::Deserializer<'de>,
7181 {
7182 const FIELDS: &[&str] = &[
7183 "status",
7184 "version",
7185 ];
7186
7187 #[allow(clippy::enum_variant_names)]
7188 enum GeneratedField {
7189 Status,
7190 Version,
7191 }
7192 impl<'de> serde::Deserialize<'de> for GeneratedField {
7193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7194 where
7195 D: serde::Deserializer<'de>,
7196 {
7197 struct GeneratedVisitor;
7198
7199 impl serde::de::Visitor<'_> for GeneratedVisitor {
7200 type Value = GeneratedField;
7201
7202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7203 write!(formatter, "expected one of: {:?}", &FIELDS)
7204 }
7205
7206 #[allow(unused_variables)]
7207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7208 where
7209 E: serde::de::Error,
7210 {
7211 match value {
7212 "status" => Ok(GeneratedField::Status),
7213 "version" => Ok(GeneratedField::Version),
7214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7215 }
7216 }
7217 }
7218 deserializer.deserialize_identifier(GeneratedVisitor)
7219 }
7220 }
7221 struct GeneratedVisitor;
7222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7223 type Value = CreateSourceResponse;
7224
7225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7226 formatter.write_str("struct ddl_service.CreateSourceResponse")
7227 }
7228
7229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
7230 where
7231 V: serde::de::MapAccess<'de>,
7232 {
7233 let mut status__ = None;
7234 let mut version__ = None;
7235 while let Some(k) = map_.next_key()? {
7236 match k {
7237 GeneratedField::Status => {
7238 if status__.is_some() {
7239 return Err(serde::de::Error::duplicate_field("status"));
7240 }
7241 status__ = map_.next_value()?;
7242 }
7243 GeneratedField::Version => {
7244 if version__.is_some() {
7245 return Err(serde::de::Error::duplicate_field("version"));
7246 }
7247 version__ = map_.next_value()?;
7248 }
7249 }
7250 }
7251 Ok(CreateSourceResponse {
7252 status: status__,
7253 version: version__,
7254 })
7255 }
7256 }
7257 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
7258 }
7259}
7260impl serde::Serialize for CreateSubscriptionRequest {
7261 #[allow(deprecated)]
7262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7263 where
7264 S: serde::Serializer,
7265 {
7266 use serde::ser::SerializeStruct;
7267 let mut len = 0;
7268 if self.subscription.is_some() {
7269 len += 1;
7270 }
7271 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
7272 if let Some(v) = self.subscription.as_ref() {
7273 struct_ser.serialize_field("subscription", v)?;
7274 }
7275 struct_ser.end()
7276 }
7277}
7278impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
7279 #[allow(deprecated)]
7280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7281 where
7282 D: serde::Deserializer<'de>,
7283 {
7284 const FIELDS: &[&str] = &[
7285 "subscription",
7286 ];
7287
7288 #[allow(clippy::enum_variant_names)]
7289 enum GeneratedField {
7290 Subscription,
7291 }
7292 impl<'de> serde::Deserialize<'de> for GeneratedField {
7293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7294 where
7295 D: serde::Deserializer<'de>,
7296 {
7297 struct GeneratedVisitor;
7298
7299 impl serde::de::Visitor<'_> for GeneratedVisitor {
7300 type Value = GeneratedField;
7301
7302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7303 write!(formatter, "expected one of: {:?}", &FIELDS)
7304 }
7305
7306 #[allow(unused_variables)]
7307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7308 where
7309 E: serde::de::Error,
7310 {
7311 match value {
7312 "subscription" => Ok(GeneratedField::Subscription),
7313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7314 }
7315 }
7316 }
7317 deserializer.deserialize_identifier(GeneratedVisitor)
7318 }
7319 }
7320 struct GeneratedVisitor;
7321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7322 type Value = CreateSubscriptionRequest;
7323
7324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7325 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
7326 }
7327
7328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
7329 where
7330 V: serde::de::MapAccess<'de>,
7331 {
7332 let mut subscription__ = None;
7333 while let Some(k) = map_.next_key()? {
7334 match k {
7335 GeneratedField::Subscription => {
7336 if subscription__.is_some() {
7337 return Err(serde::de::Error::duplicate_field("subscription"));
7338 }
7339 subscription__ = map_.next_value()?;
7340 }
7341 }
7342 }
7343 Ok(CreateSubscriptionRequest {
7344 subscription: subscription__,
7345 })
7346 }
7347 }
7348 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
7349 }
7350}
7351impl serde::Serialize for CreateSubscriptionResponse {
7352 #[allow(deprecated)]
7353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7354 where
7355 S: serde::Serializer,
7356 {
7357 use serde::ser::SerializeStruct;
7358 let mut len = 0;
7359 if self.status.is_some() {
7360 len += 1;
7361 }
7362 if self.version.is_some() {
7363 len += 1;
7364 }
7365 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
7366 if let Some(v) = self.status.as_ref() {
7367 struct_ser.serialize_field("status", v)?;
7368 }
7369 if let Some(v) = self.version.as_ref() {
7370 struct_ser.serialize_field("version", v)?;
7371 }
7372 struct_ser.end()
7373 }
7374}
7375impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
7376 #[allow(deprecated)]
7377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7378 where
7379 D: serde::Deserializer<'de>,
7380 {
7381 const FIELDS: &[&str] = &[
7382 "status",
7383 "version",
7384 ];
7385
7386 #[allow(clippy::enum_variant_names)]
7387 enum GeneratedField {
7388 Status,
7389 Version,
7390 }
7391 impl<'de> serde::Deserialize<'de> for GeneratedField {
7392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7393 where
7394 D: serde::Deserializer<'de>,
7395 {
7396 struct GeneratedVisitor;
7397
7398 impl serde::de::Visitor<'_> for GeneratedVisitor {
7399 type Value = GeneratedField;
7400
7401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7402 write!(formatter, "expected one of: {:?}", &FIELDS)
7403 }
7404
7405 #[allow(unused_variables)]
7406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7407 where
7408 E: serde::de::Error,
7409 {
7410 match value {
7411 "status" => Ok(GeneratedField::Status),
7412 "version" => Ok(GeneratedField::Version),
7413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7414 }
7415 }
7416 }
7417 deserializer.deserialize_identifier(GeneratedVisitor)
7418 }
7419 }
7420 struct GeneratedVisitor;
7421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7422 type Value = CreateSubscriptionResponse;
7423
7424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7425 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
7426 }
7427
7428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
7429 where
7430 V: serde::de::MapAccess<'de>,
7431 {
7432 let mut status__ = None;
7433 let mut version__ = None;
7434 while let Some(k) = map_.next_key()? {
7435 match k {
7436 GeneratedField::Status => {
7437 if status__.is_some() {
7438 return Err(serde::de::Error::duplicate_field("status"));
7439 }
7440 status__ = map_.next_value()?;
7441 }
7442 GeneratedField::Version => {
7443 if version__.is_some() {
7444 return Err(serde::de::Error::duplicate_field("version"));
7445 }
7446 version__ = map_.next_value()?;
7447 }
7448 }
7449 }
7450 Ok(CreateSubscriptionResponse {
7451 status: status__,
7452 version: version__,
7453 })
7454 }
7455 }
7456 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
7457 }
7458}
7459impl serde::Serialize for CreateTableRequest {
7460 #[allow(deprecated)]
7461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7462 where
7463 S: serde::Serializer,
7464 {
7465 use serde::ser::SerializeStruct;
7466 let mut len = 0;
7467 if self.source.is_some() {
7468 len += 1;
7469 }
7470 if self.materialized_view.is_some() {
7471 len += 1;
7472 }
7473 if self.fragment_graph.is_some() {
7474 len += 1;
7475 }
7476 if self.job_type != 0 {
7477 len += 1;
7478 }
7479 if self.if_not_exists {
7480 len += 1;
7481 }
7482 if !self.dependencies.is_empty() {
7483 len += 1;
7484 }
7485 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
7486 if let Some(v) = self.source.as_ref() {
7487 struct_ser.serialize_field("source", v)?;
7488 }
7489 if let Some(v) = self.materialized_view.as_ref() {
7490 struct_ser.serialize_field("materializedView", v)?;
7491 }
7492 if let Some(v) = self.fragment_graph.as_ref() {
7493 struct_ser.serialize_field("fragmentGraph", v)?;
7494 }
7495 if self.job_type != 0 {
7496 let v = TableJobType::try_from(self.job_type)
7497 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
7498 struct_ser.serialize_field("jobType", &v)?;
7499 }
7500 if self.if_not_exists {
7501 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7502 }
7503 if !self.dependencies.is_empty() {
7504 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7505 }
7506 struct_ser.end()
7507 }
7508}
7509impl<'de> serde::Deserialize<'de> for CreateTableRequest {
7510 #[allow(deprecated)]
7511 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7512 where
7513 D: serde::Deserializer<'de>,
7514 {
7515 const FIELDS: &[&str] = &[
7516 "source",
7517 "materialized_view",
7518 "materializedView",
7519 "fragment_graph",
7520 "fragmentGraph",
7521 "job_type",
7522 "jobType",
7523 "if_not_exists",
7524 "ifNotExists",
7525 "dependencies",
7526 ];
7527
7528 #[allow(clippy::enum_variant_names)]
7529 enum GeneratedField {
7530 Source,
7531 MaterializedView,
7532 FragmentGraph,
7533 JobType,
7534 IfNotExists,
7535 Dependencies,
7536 }
7537 impl<'de> serde::Deserialize<'de> for GeneratedField {
7538 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7539 where
7540 D: serde::Deserializer<'de>,
7541 {
7542 struct GeneratedVisitor;
7543
7544 impl serde::de::Visitor<'_> for GeneratedVisitor {
7545 type Value = GeneratedField;
7546
7547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7548 write!(formatter, "expected one of: {:?}", &FIELDS)
7549 }
7550
7551 #[allow(unused_variables)]
7552 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7553 where
7554 E: serde::de::Error,
7555 {
7556 match value {
7557 "source" => Ok(GeneratedField::Source),
7558 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
7559 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7560 "jobType" | "job_type" => Ok(GeneratedField::JobType),
7561 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7562 "dependencies" => Ok(GeneratedField::Dependencies),
7563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7564 }
7565 }
7566 }
7567 deserializer.deserialize_identifier(GeneratedVisitor)
7568 }
7569 }
7570 struct GeneratedVisitor;
7571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7572 type Value = CreateTableRequest;
7573
7574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7575 formatter.write_str("struct ddl_service.CreateTableRequest")
7576 }
7577
7578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
7579 where
7580 V: serde::de::MapAccess<'de>,
7581 {
7582 let mut source__ = None;
7583 let mut materialized_view__ = None;
7584 let mut fragment_graph__ = None;
7585 let mut job_type__ = None;
7586 let mut if_not_exists__ = None;
7587 let mut dependencies__ = None;
7588 while let Some(k) = map_.next_key()? {
7589 match k {
7590 GeneratedField::Source => {
7591 if source__.is_some() {
7592 return Err(serde::de::Error::duplicate_field("source"));
7593 }
7594 source__ = map_.next_value()?;
7595 }
7596 GeneratedField::MaterializedView => {
7597 if materialized_view__.is_some() {
7598 return Err(serde::de::Error::duplicate_field("materializedView"));
7599 }
7600 materialized_view__ = map_.next_value()?;
7601 }
7602 GeneratedField::FragmentGraph => {
7603 if fragment_graph__.is_some() {
7604 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7605 }
7606 fragment_graph__ = map_.next_value()?;
7607 }
7608 GeneratedField::JobType => {
7609 if job_type__.is_some() {
7610 return Err(serde::de::Error::duplicate_field("jobType"));
7611 }
7612 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
7613 }
7614 GeneratedField::IfNotExists => {
7615 if if_not_exists__.is_some() {
7616 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7617 }
7618 if_not_exists__ = Some(map_.next_value()?);
7619 }
7620 GeneratedField::Dependencies => {
7621 if dependencies__.is_some() {
7622 return Err(serde::de::Error::duplicate_field("dependencies"));
7623 }
7624 dependencies__ =
7625 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7626 .into_iter().map(|x| x.0).collect())
7627 ;
7628 }
7629 }
7630 }
7631 Ok(CreateTableRequest {
7632 source: source__,
7633 materialized_view: materialized_view__,
7634 fragment_graph: fragment_graph__,
7635 job_type: job_type__.unwrap_or_default(),
7636 if_not_exists: if_not_exists__.unwrap_or_default(),
7637 dependencies: dependencies__.unwrap_or_default(),
7638 })
7639 }
7640 }
7641 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
7642 }
7643}
7644impl serde::Serialize for CreateTableResponse {
7645 #[allow(deprecated)]
7646 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7647 where
7648 S: serde::Serializer,
7649 {
7650 use serde::ser::SerializeStruct;
7651 let mut len = 0;
7652 if self.status.is_some() {
7653 len += 1;
7654 }
7655 if self.version.is_some() {
7656 len += 1;
7657 }
7658 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
7659 if let Some(v) = self.status.as_ref() {
7660 struct_ser.serialize_field("status", v)?;
7661 }
7662 if let Some(v) = self.version.as_ref() {
7663 struct_ser.serialize_field("version", v)?;
7664 }
7665 struct_ser.end()
7666 }
7667}
7668impl<'de> serde::Deserialize<'de> for CreateTableResponse {
7669 #[allow(deprecated)]
7670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7671 where
7672 D: serde::Deserializer<'de>,
7673 {
7674 const FIELDS: &[&str] = &[
7675 "status",
7676 "version",
7677 ];
7678
7679 #[allow(clippy::enum_variant_names)]
7680 enum GeneratedField {
7681 Status,
7682 Version,
7683 }
7684 impl<'de> serde::Deserialize<'de> for GeneratedField {
7685 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7686 where
7687 D: serde::Deserializer<'de>,
7688 {
7689 struct GeneratedVisitor;
7690
7691 impl serde::de::Visitor<'_> for GeneratedVisitor {
7692 type Value = GeneratedField;
7693
7694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7695 write!(formatter, "expected one of: {:?}", &FIELDS)
7696 }
7697
7698 #[allow(unused_variables)]
7699 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7700 where
7701 E: serde::de::Error,
7702 {
7703 match value {
7704 "status" => Ok(GeneratedField::Status),
7705 "version" => Ok(GeneratedField::Version),
7706 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7707 }
7708 }
7709 }
7710 deserializer.deserialize_identifier(GeneratedVisitor)
7711 }
7712 }
7713 struct GeneratedVisitor;
7714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7715 type Value = CreateTableResponse;
7716
7717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7718 formatter.write_str("struct ddl_service.CreateTableResponse")
7719 }
7720
7721 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
7722 where
7723 V: serde::de::MapAccess<'de>,
7724 {
7725 let mut status__ = None;
7726 let mut version__ = None;
7727 while let Some(k) = map_.next_key()? {
7728 match k {
7729 GeneratedField::Status => {
7730 if status__.is_some() {
7731 return Err(serde::de::Error::duplicate_field("status"));
7732 }
7733 status__ = map_.next_value()?;
7734 }
7735 GeneratedField::Version => {
7736 if version__.is_some() {
7737 return Err(serde::de::Error::duplicate_field("version"));
7738 }
7739 version__ = map_.next_value()?;
7740 }
7741 }
7742 }
7743 Ok(CreateTableResponse {
7744 status: status__,
7745 version: version__,
7746 })
7747 }
7748 }
7749 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
7750 }
7751}
7752impl serde::Serialize for CreateViewRequest {
7753 #[allow(deprecated)]
7754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7755 where
7756 S: serde::Serializer,
7757 {
7758 use serde::ser::SerializeStruct;
7759 let mut len = 0;
7760 if self.view.is_some() {
7761 len += 1;
7762 }
7763 if !self.dependencies.is_empty() {
7764 len += 1;
7765 }
7766 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
7767 if let Some(v) = self.view.as_ref() {
7768 struct_ser.serialize_field("view", v)?;
7769 }
7770 if !self.dependencies.is_empty() {
7771 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7772 }
7773 struct_ser.end()
7774 }
7775}
7776impl<'de> serde::Deserialize<'de> for CreateViewRequest {
7777 #[allow(deprecated)]
7778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7779 where
7780 D: serde::Deserializer<'de>,
7781 {
7782 const FIELDS: &[&str] = &[
7783 "view",
7784 "dependencies",
7785 ];
7786
7787 #[allow(clippy::enum_variant_names)]
7788 enum GeneratedField {
7789 View,
7790 Dependencies,
7791 }
7792 impl<'de> serde::Deserialize<'de> for GeneratedField {
7793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7794 where
7795 D: serde::Deserializer<'de>,
7796 {
7797 struct GeneratedVisitor;
7798
7799 impl serde::de::Visitor<'_> for GeneratedVisitor {
7800 type Value = GeneratedField;
7801
7802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7803 write!(formatter, "expected one of: {:?}", &FIELDS)
7804 }
7805
7806 #[allow(unused_variables)]
7807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7808 where
7809 E: serde::de::Error,
7810 {
7811 match value {
7812 "view" => Ok(GeneratedField::View),
7813 "dependencies" => Ok(GeneratedField::Dependencies),
7814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7815 }
7816 }
7817 }
7818 deserializer.deserialize_identifier(GeneratedVisitor)
7819 }
7820 }
7821 struct GeneratedVisitor;
7822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7823 type Value = CreateViewRequest;
7824
7825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7826 formatter.write_str("struct ddl_service.CreateViewRequest")
7827 }
7828
7829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7830 where
7831 V: serde::de::MapAccess<'de>,
7832 {
7833 let mut view__ = None;
7834 let mut dependencies__ = None;
7835 while let Some(k) = map_.next_key()? {
7836 match k {
7837 GeneratedField::View => {
7838 if view__.is_some() {
7839 return Err(serde::de::Error::duplicate_field("view"));
7840 }
7841 view__ = map_.next_value()?;
7842 }
7843 GeneratedField::Dependencies => {
7844 if dependencies__.is_some() {
7845 return Err(serde::de::Error::duplicate_field("dependencies"));
7846 }
7847 dependencies__ =
7848 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7849 .into_iter().map(|x| x.0).collect())
7850 ;
7851 }
7852 }
7853 }
7854 Ok(CreateViewRequest {
7855 view: view__,
7856 dependencies: dependencies__.unwrap_or_default(),
7857 })
7858 }
7859 }
7860 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7861 }
7862}
7863impl serde::Serialize for CreateViewResponse {
7864 #[allow(deprecated)]
7865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7866 where
7867 S: serde::Serializer,
7868 {
7869 use serde::ser::SerializeStruct;
7870 let mut len = 0;
7871 if self.status.is_some() {
7872 len += 1;
7873 }
7874 if self.version.is_some() {
7875 len += 1;
7876 }
7877 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7878 if let Some(v) = self.status.as_ref() {
7879 struct_ser.serialize_field("status", v)?;
7880 }
7881 if let Some(v) = self.version.as_ref() {
7882 struct_ser.serialize_field("version", v)?;
7883 }
7884 struct_ser.end()
7885 }
7886}
7887impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7888 #[allow(deprecated)]
7889 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7890 where
7891 D: serde::Deserializer<'de>,
7892 {
7893 const FIELDS: &[&str] = &[
7894 "status",
7895 "version",
7896 ];
7897
7898 #[allow(clippy::enum_variant_names)]
7899 enum GeneratedField {
7900 Status,
7901 Version,
7902 }
7903 impl<'de> serde::Deserialize<'de> for GeneratedField {
7904 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7905 where
7906 D: serde::Deserializer<'de>,
7907 {
7908 struct GeneratedVisitor;
7909
7910 impl serde::de::Visitor<'_> for GeneratedVisitor {
7911 type Value = GeneratedField;
7912
7913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7914 write!(formatter, "expected one of: {:?}", &FIELDS)
7915 }
7916
7917 #[allow(unused_variables)]
7918 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7919 where
7920 E: serde::de::Error,
7921 {
7922 match value {
7923 "status" => Ok(GeneratedField::Status),
7924 "version" => Ok(GeneratedField::Version),
7925 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7926 }
7927 }
7928 }
7929 deserializer.deserialize_identifier(GeneratedVisitor)
7930 }
7931 }
7932 struct GeneratedVisitor;
7933 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7934 type Value = CreateViewResponse;
7935
7936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7937 formatter.write_str("struct ddl_service.CreateViewResponse")
7938 }
7939
7940 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7941 where
7942 V: serde::de::MapAccess<'de>,
7943 {
7944 let mut status__ = None;
7945 let mut version__ = None;
7946 while let Some(k) = map_.next_key()? {
7947 match k {
7948 GeneratedField::Status => {
7949 if status__.is_some() {
7950 return Err(serde::de::Error::duplicate_field("status"));
7951 }
7952 status__ = map_.next_value()?;
7953 }
7954 GeneratedField::Version => {
7955 if version__.is_some() {
7956 return Err(serde::de::Error::duplicate_field("version"));
7957 }
7958 version__ = map_.next_value()?;
7959 }
7960 }
7961 }
7962 Ok(CreateViewResponse {
7963 status: status__,
7964 version: version__,
7965 })
7966 }
7967 }
7968 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7969 }
7970}
7971impl serde::Serialize for DdlProgress {
7972 #[allow(deprecated)]
7973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7974 where
7975 S: serde::Serializer,
7976 {
7977 use serde::ser::SerializeStruct;
7978 let mut len = 0;
7979 if self.id != 0 {
7980 len += 1;
7981 }
7982 if !self.statement.is_empty() {
7983 len += 1;
7984 }
7985 if !self.progress.is_empty() {
7986 len += 1;
7987 }
7988 if !self.create_type.is_empty() {
7989 len += 1;
7990 }
7991 if self.initialized_at_time_millis != 0 {
7992 len += 1;
7993 }
7994 if self.is_serverless_backfill {
7995 len += 1;
7996 }
7997 if self.backfill_type != 0 {
7998 len += 1;
7999 }
8000 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
8001 if self.id != 0 {
8002 #[allow(clippy::needless_borrow)]
8003 #[allow(clippy::needless_borrows_for_generic_args)]
8004 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
8005 }
8006 if !self.statement.is_empty() {
8007 struct_ser.serialize_field("statement", &self.statement)?;
8008 }
8009 if !self.progress.is_empty() {
8010 struct_ser.serialize_field("progress", &self.progress)?;
8011 }
8012 if !self.create_type.is_empty() {
8013 struct_ser.serialize_field("createType", &self.create_type)?;
8014 }
8015 if self.initialized_at_time_millis != 0 {
8016 #[allow(clippy::needless_borrow)]
8017 #[allow(clippy::needless_borrows_for_generic_args)]
8018 struct_ser.serialize_field("initializedAtTimeMillis", ToString::to_string(&self.initialized_at_time_millis).as_str())?;
8019 }
8020 if self.is_serverless_backfill {
8021 struct_ser.serialize_field("isServerlessBackfill", &self.is_serverless_backfill)?;
8022 }
8023 if self.backfill_type != 0 {
8024 let v = BackfillType::try_from(self.backfill_type)
8025 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill_type)))?;
8026 struct_ser.serialize_field("backfillType", &v)?;
8027 }
8028 struct_ser.end()
8029 }
8030}
8031impl<'de> serde::Deserialize<'de> for DdlProgress {
8032 #[allow(deprecated)]
8033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8034 where
8035 D: serde::Deserializer<'de>,
8036 {
8037 const FIELDS: &[&str] = &[
8038 "id",
8039 "statement",
8040 "progress",
8041 "create_type",
8042 "createType",
8043 "initialized_at_time_millis",
8044 "initializedAtTimeMillis",
8045 "is_serverless_backfill",
8046 "isServerlessBackfill",
8047 "backfill_type",
8048 "backfillType",
8049 ];
8050
8051 #[allow(clippy::enum_variant_names)]
8052 enum GeneratedField {
8053 Id,
8054 Statement,
8055 Progress,
8056 CreateType,
8057 InitializedAtTimeMillis,
8058 IsServerlessBackfill,
8059 BackfillType,
8060 }
8061 impl<'de> serde::Deserialize<'de> for GeneratedField {
8062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8063 where
8064 D: serde::Deserializer<'de>,
8065 {
8066 struct GeneratedVisitor;
8067
8068 impl serde::de::Visitor<'_> for GeneratedVisitor {
8069 type Value = GeneratedField;
8070
8071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8072 write!(formatter, "expected one of: {:?}", &FIELDS)
8073 }
8074
8075 #[allow(unused_variables)]
8076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8077 where
8078 E: serde::de::Error,
8079 {
8080 match value {
8081 "id" => Ok(GeneratedField::Id),
8082 "statement" => Ok(GeneratedField::Statement),
8083 "progress" => Ok(GeneratedField::Progress),
8084 "createType" | "create_type" => Ok(GeneratedField::CreateType),
8085 "initializedAtTimeMillis" | "initialized_at_time_millis" => Ok(GeneratedField::InitializedAtTimeMillis),
8086 "isServerlessBackfill" | "is_serverless_backfill" => Ok(GeneratedField::IsServerlessBackfill),
8087 "backfillType" | "backfill_type" => Ok(GeneratedField::BackfillType),
8088 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8089 }
8090 }
8091 }
8092 deserializer.deserialize_identifier(GeneratedVisitor)
8093 }
8094 }
8095 struct GeneratedVisitor;
8096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8097 type Value = DdlProgress;
8098
8099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8100 formatter.write_str("struct ddl_service.DdlProgress")
8101 }
8102
8103 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
8104 where
8105 V: serde::de::MapAccess<'de>,
8106 {
8107 let mut id__ = None;
8108 let mut statement__ = None;
8109 let mut progress__ = None;
8110 let mut create_type__ = None;
8111 let mut initialized_at_time_millis__ = None;
8112 let mut is_serverless_backfill__ = None;
8113 let mut backfill_type__ = None;
8114 while let Some(k) = map_.next_key()? {
8115 match k {
8116 GeneratedField::Id => {
8117 if id__.is_some() {
8118 return Err(serde::de::Error::duplicate_field("id"));
8119 }
8120 id__ =
8121 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8122 ;
8123 }
8124 GeneratedField::Statement => {
8125 if statement__.is_some() {
8126 return Err(serde::de::Error::duplicate_field("statement"));
8127 }
8128 statement__ = Some(map_.next_value()?);
8129 }
8130 GeneratedField::Progress => {
8131 if progress__.is_some() {
8132 return Err(serde::de::Error::duplicate_field("progress"));
8133 }
8134 progress__ = Some(map_.next_value()?);
8135 }
8136 GeneratedField::CreateType => {
8137 if create_type__.is_some() {
8138 return Err(serde::de::Error::duplicate_field("createType"));
8139 }
8140 create_type__ = Some(map_.next_value()?);
8141 }
8142 GeneratedField::InitializedAtTimeMillis => {
8143 if initialized_at_time_millis__.is_some() {
8144 return Err(serde::de::Error::duplicate_field("initializedAtTimeMillis"));
8145 }
8146 initialized_at_time_millis__ =
8147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8148 ;
8149 }
8150 GeneratedField::IsServerlessBackfill => {
8151 if is_serverless_backfill__.is_some() {
8152 return Err(serde::de::Error::duplicate_field("isServerlessBackfill"));
8153 }
8154 is_serverless_backfill__ = Some(map_.next_value()?);
8155 }
8156 GeneratedField::BackfillType => {
8157 if backfill_type__.is_some() {
8158 return Err(serde::de::Error::duplicate_field("backfillType"));
8159 }
8160 backfill_type__ = Some(map_.next_value::<BackfillType>()? as i32);
8161 }
8162 }
8163 }
8164 Ok(DdlProgress {
8165 id: id__.unwrap_or_default(),
8166 statement: statement__.unwrap_or_default(),
8167 progress: progress__.unwrap_or_default(),
8168 create_type: create_type__.unwrap_or_default(),
8169 initialized_at_time_millis: initialized_at_time_millis__.unwrap_or_default(),
8170 is_serverless_backfill: is_serverless_backfill__.unwrap_or_default(),
8171 backfill_type: backfill_type__.unwrap_or_default(),
8172 })
8173 }
8174 }
8175 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
8176 }
8177}
8178impl serde::Serialize for DropConnectionRequest {
8179 #[allow(deprecated)]
8180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8181 where
8182 S: serde::Serializer,
8183 {
8184 use serde::ser::SerializeStruct;
8185 let mut len = 0;
8186 if self.connection_id != 0 {
8187 len += 1;
8188 }
8189 if self.cascade {
8190 len += 1;
8191 }
8192 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
8193 if self.connection_id != 0 {
8194 struct_ser.serialize_field("connectionId", &self.connection_id)?;
8195 }
8196 if self.cascade {
8197 struct_ser.serialize_field("cascade", &self.cascade)?;
8198 }
8199 struct_ser.end()
8200 }
8201}
8202impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
8203 #[allow(deprecated)]
8204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8205 where
8206 D: serde::Deserializer<'de>,
8207 {
8208 const FIELDS: &[&str] = &[
8209 "connection_id",
8210 "connectionId",
8211 "cascade",
8212 ];
8213
8214 #[allow(clippy::enum_variant_names)]
8215 enum GeneratedField {
8216 ConnectionId,
8217 Cascade,
8218 }
8219 impl<'de> serde::Deserialize<'de> for GeneratedField {
8220 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8221 where
8222 D: serde::Deserializer<'de>,
8223 {
8224 struct GeneratedVisitor;
8225
8226 impl serde::de::Visitor<'_> for GeneratedVisitor {
8227 type Value = GeneratedField;
8228
8229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8230 write!(formatter, "expected one of: {:?}", &FIELDS)
8231 }
8232
8233 #[allow(unused_variables)]
8234 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8235 where
8236 E: serde::de::Error,
8237 {
8238 match value {
8239 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
8240 "cascade" => Ok(GeneratedField::Cascade),
8241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8242 }
8243 }
8244 }
8245 deserializer.deserialize_identifier(GeneratedVisitor)
8246 }
8247 }
8248 struct GeneratedVisitor;
8249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8250 type Value = DropConnectionRequest;
8251
8252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8253 formatter.write_str("struct ddl_service.DropConnectionRequest")
8254 }
8255
8256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
8257 where
8258 V: serde::de::MapAccess<'de>,
8259 {
8260 let mut connection_id__ = None;
8261 let mut cascade__ = None;
8262 while let Some(k) = map_.next_key()? {
8263 match k {
8264 GeneratedField::ConnectionId => {
8265 if connection_id__.is_some() {
8266 return Err(serde::de::Error::duplicate_field("connectionId"));
8267 }
8268 connection_id__ =
8269 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8270 ;
8271 }
8272 GeneratedField::Cascade => {
8273 if cascade__.is_some() {
8274 return Err(serde::de::Error::duplicate_field("cascade"));
8275 }
8276 cascade__ = Some(map_.next_value()?);
8277 }
8278 }
8279 }
8280 Ok(DropConnectionRequest {
8281 connection_id: connection_id__.unwrap_or_default(),
8282 cascade: cascade__.unwrap_or_default(),
8283 })
8284 }
8285 }
8286 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
8287 }
8288}
8289impl serde::Serialize for DropConnectionResponse {
8290 #[allow(deprecated)]
8291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8292 where
8293 S: serde::Serializer,
8294 {
8295 use serde::ser::SerializeStruct;
8296 let mut len = 0;
8297 if self.status.is_some() {
8298 len += 1;
8299 }
8300 if self.version.is_some() {
8301 len += 1;
8302 }
8303 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
8304 if let Some(v) = self.status.as_ref() {
8305 struct_ser.serialize_field("status", v)?;
8306 }
8307 if let Some(v) = self.version.as_ref() {
8308 struct_ser.serialize_field("version", v)?;
8309 }
8310 struct_ser.end()
8311 }
8312}
8313impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
8314 #[allow(deprecated)]
8315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8316 where
8317 D: serde::Deserializer<'de>,
8318 {
8319 const FIELDS: &[&str] = &[
8320 "status",
8321 "version",
8322 ];
8323
8324 #[allow(clippy::enum_variant_names)]
8325 enum GeneratedField {
8326 Status,
8327 Version,
8328 }
8329 impl<'de> serde::Deserialize<'de> for GeneratedField {
8330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8331 where
8332 D: serde::Deserializer<'de>,
8333 {
8334 struct GeneratedVisitor;
8335
8336 impl serde::de::Visitor<'_> for GeneratedVisitor {
8337 type Value = GeneratedField;
8338
8339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8340 write!(formatter, "expected one of: {:?}", &FIELDS)
8341 }
8342
8343 #[allow(unused_variables)]
8344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8345 where
8346 E: serde::de::Error,
8347 {
8348 match value {
8349 "status" => Ok(GeneratedField::Status),
8350 "version" => Ok(GeneratedField::Version),
8351 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8352 }
8353 }
8354 }
8355 deserializer.deserialize_identifier(GeneratedVisitor)
8356 }
8357 }
8358 struct GeneratedVisitor;
8359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8360 type Value = DropConnectionResponse;
8361
8362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8363 formatter.write_str("struct ddl_service.DropConnectionResponse")
8364 }
8365
8366 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
8367 where
8368 V: serde::de::MapAccess<'de>,
8369 {
8370 let mut status__ = None;
8371 let mut version__ = None;
8372 while let Some(k) = map_.next_key()? {
8373 match k {
8374 GeneratedField::Status => {
8375 if status__.is_some() {
8376 return Err(serde::de::Error::duplicate_field("status"));
8377 }
8378 status__ = map_.next_value()?;
8379 }
8380 GeneratedField::Version => {
8381 if version__.is_some() {
8382 return Err(serde::de::Error::duplicate_field("version"));
8383 }
8384 version__ = map_.next_value()?;
8385 }
8386 }
8387 }
8388 Ok(DropConnectionResponse {
8389 status: status__,
8390 version: version__,
8391 })
8392 }
8393 }
8394 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
8395 }
8396}
8397impl serde::Serialize for DropDatabaseRequest {
8398 #[allow(deprecated)]
8399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8400 where
8401 S: serde::Serializer,
8402 {
8403 use serde::ser::SerializeStruct;
8404 let mut len = 0;
8405 if self.database_id != 0 {
8406 len += 1;
8407 }
8408 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
8409 if self.database_id != 0 {
8410 struct_ser.serialize_field("databaseId", &self.database_id)?;
8411 }
8412 struct_ser.end()
8413 }
8414}
8415impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
8416 #[allow(deprecated)]
8417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8418 where
8419 D: serde::Deserializer<'de>,
8420 {
8421 const FIELDS: &[&str] = &[
8422 "database_id",
8423 "databaseId",
8424 ];
8425
8426 #[allow(clippy::enum_variant_names)]
8427 enum GeneratedField {
8428 DatabaseId,
8429 }
8430 impl<'de> serde::Deserialize<'de> for GeneratedField {
8431 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8432 where
8433 D: serde::Deserializer<'de>,
8434 {
8435 struct GeneratedVisitor;
8436
8437 impl serde::de::Visitor<'_> for GeneratedVisitor {
8438 type Value = GeneratedField;
8439
8440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8441 write!(formatter, "expected one of: {:?}", &FIELDS)
8442 }
8443
8444 #[allow(unused_variables)]
8445 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8446 where
8447 E: serde::de::Error,
8448 {
8449 match value {
8450 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
8451 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8452 }
8453 }
8454 }
8455 deserializer.deserialize_identifier(GeneratedVisitor)
8456 }
8457 }
8458 struct GeneratedVisitor;
8459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8460 type Value = DropDatabaseRequest;
8461
8462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8463 formatter.write_str("struct ddl_service.DropDatabaseRequest")
8464 }
8465
8466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
8467 where
8468 V: serde::de::MapAccess<'de>,
8469 {
8470 let mut database_id__ = None;
8471 while let Some(k) = map_.next_key()? {
8472 match k {
8473 GeneratedField::DatabaseId => {
8474 if database_id__.is_some() {
8475 return Err(serde::de::Error::duplicate_field("databaseId"));
8476 }
8477 database_id__ =
8478 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8479 ;
8480 }
8481 }
8482 }
8483 Ok(DropDatabaseRequest {
8484 database_id: database_id__.unwrap_or_default(),
8485 })
8486 }
8487 }
8488 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
8489 }
8490}
8491impl serde::Serialize for DropDatabaseResponse {
8492 #[allow(deprecated)]
8493 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8494 where
8495 S: serde::Serializer,
8496 {
8497 use serde::ser::SerializeStruct;
8498 let mut len = 0;
8499 if self.status.is_some() {
8500 len += 1;
8501 }
8502 if self.version.is_some() {
8503 len += 1;
8504 }
8505 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
8506 if let Some(v) = self.status.as_ref() {
8507 struct_ser.serialize_field("status", v)?;
8508 }
8509 if let Some(v) = self.version.as_ref() {
8510 struct_ser.serialize_field("version", v)?;
8511 }
8512 struct_ser.end()
8513 }
8514}
8515impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
8516 #[allow(deprecated)]
8517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8518 where
8519 D: serde::Deserializer<'de>,
8520 {
8521 const FIELDS: &[&str] = &[
8522 "status",
8523 "version",
8524 ];
8525
8526 #[allow(clippy::enum_variant_names)]
8527 enum GeneratedField {
8528 Status,
8529 Version,
8530 }
8531 impl<'de> serde::Deserialize<'de> for GeneratedField {
8532 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8533 where
8534 D: serde::Deserializer<'de>,
8535 {
8536 struct GeneratedVisitor;
8537
8538 impl serde::de::Visitor<'_> for GeneratedVisitor {
8539 type Value = GeneratedField;
8540
8541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8542 write!(formatter, "expected one of: {:?}", &FIELDS)
8543 }
8544
8545 #[allow(unused_variables)]
8546 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8547 where
8548 E: serde::de::Error,
8549 {
8550 match value {
8551 "status" => Ok(GeneratedField::Status),
8552 "version" => Ok(GeneratedField::Version),
8553 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8554 }
8555 }
8556 }
8557 deserializer.deserialize_identifier(GeneratedVisitor)
8558 }
8559 }
8560 struct GeneratedVisitor;
8561 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8562 type Value = DropDatabaseResponse;
8563
8564 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8565 formatter.write_str("struct ddl_service.DropDatabaseResponse")
8566 }
8567
8568 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
8569 where
8570 V: serde::de::MapAccess<'de>,
8571 {
8572 let mut status__ = None;
8573 let mut version__ = None;
8574 while let Some(k) = map_.next_key()? {
8575 match k {
8576 GeneratedField::Status => {
8577 if status__.is_some() {
8578 return Err(serde::de::Error::duplicate_field("status"));
8579 }
8580 status__ = map_.next_value()?;
8581 }
8582 GeneratedField::Version => {
8583 if version__.is_some() {
8584 return Err(serde::de::Error::duplicate_field("version"));
8585 }
8586 version__ = map_.next_value()?;
8587 }
8588 }
8589 }
8590 Ok(DropDatabaseResponse {
8591 status: status__,
8592 version: version__,
8593 })
8594 }
8595 }
8596 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
8597 }
8598}
8599impl serde::Serialize for DropFunctionRequest {
8600 #[allow(deprecated)]
8601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8602 where
8603 S: serde::Serializer,
8604 {
8605 use serde::ser::SerializeStruct;
8606 let mut len = 0;
8607 if self.function_id != 0 {
8608 len += 1;
8609 }
8610 if self.cascade {
8611 len += 1;
8612 }
8613 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
8614 if self.function_id != 0 {
8615 struct_ser.serialize_field("functionId", &self.function_id)?;
8616 }
8617 if self.cascade {
8618 struct_ser.serialize_field("cascade", &self.cascade)?;
8619 }
8620 struct_ser.end()
8621 }
8622}
8623impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
8624 #[allow(deprecated)]
8625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8626 where
8627 D: serde::Deserializer<'de>,
8628 {
8629 const FIELDS: &[&str] = &[
8630 "function_id",
8631 "functionId",
8632 "cascade",
8633 ];
8634
8635 #[allow(clippy::enum_variant_names)]
8636 enum GeneratedField {
8637 FunctionId,
8638 Cascade,
8639 }
8640 impl<'de> serde::Deserialize<'de> for GeneratedField {
8641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8642 where
8643 D: serde::Deserializer<'de>,
8644 {
8645 struct GeneratedVisitor;
8646
8647 impl serde::de::Visitor<'_> for GeneratedVisitor {
8648 type Value = GeneratedField;
8649
8650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8651 write!(formatter, "expected one of: {:?}", &FIELDS)
8652 }
8653
8654 #[allow(unused_variables)]
8655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8656 where
8657 E: serde::de::Error,
8658 {
8659 match value {
8660 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
8661 "cascade" => Ok(GeneratedField::Cascade),
8662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8663 }
8664 }
8665 }
8666 deserializer.deserialize_identifier(GeneratedVisitor)
8667 }
8668 }
8669 struct GeneratedVisitor;
8670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8671 type Value = DropFunctionRequest;
8672
8673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8674 formatter.write_str("struct ddl_service.DropFunctionRequest")
8675 }
8676
8677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
8678 where
8679 V: serde::de::MapAccess<'de>,
8680 {
8681 let mut function_id__ = None;
8682 let mut cascade__ = None;
8683 while let Some(k) = map_.next_key()? {
8684 match k {
8685 GeneratedField::FunctionId => {
8686 if function_id__.is_some() {
8687 return Err(serde::de::Error::duplicate_field("functionId"));
8688 }
8689 function_id__ =
8690 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8691 ;
8692 }
8693 GeneratedField::Cascade => {
8694 if cascade__.is_some() {
8695 return Err(serde::de::Error::duplicate_field("cascade"));
8696 }
8697 cascade__ = Some(map_.next_value()?);
8698 }
8699 }
8700 }
8701 Ok(DropFunctionRequest {
8702 function_id: function_id__.unwrap_or_default(),
8703 cascade: cascade__.unwrap_or_default(),
8704 })
8705 }
8706 }
8707 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
8708 }
8709}
8710impl serde::Serialize for DropFunctionResponse {
8711 #[allow(deprecated)]
8712 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8713 where
8714 S: serde::Serializer,
8715 {
8716 use serde::ser::SerializeStruct;
8717 let mut len = 0;
8718 if self.status.is_some() {
8719 len += 1;
8720 }
8721 if self.version.is_some() {
8722 len += 1;
8723 }
8724 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
8725 if let Some(v) = self.status.as_ref() {
8726 struct_ser.serialize_field("status", v)?;
8727 }
8728 if let Some(v) = self.version.as_ref() {
8729 struct_ser.serialize_field("version", v)?;
8730 }
8731 struct_ser.end()
8732 }
8733}
8734impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
8735 #[allow(deprecated)]
8736 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8737 where
8738 D: serde::Deserializer<'de>,
8739 {
8740 const FIELDS: &[&str] = &[
8741 "status",
8742 "version",
8743 ];
8744
8745 #[allow(clippy::enum_variant_names)]
8746 enum GeneratedField {
8747 Status,
8748 Version,
8749 }
8750 impl<'de> serde::Deserialize<'de> for GeneratedField {
8751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8752 where
8753 D: serde::Deserializer<'de>,
8754 {
8755 struct GeneratedVisitor;
8756
8757 impl serde::de::Visitor<'_> for GeneratedVisitor {
8758 type Value = GeneratedField;
8759
8760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8761 write!(formatter, "expected one of: {:?}", &FIELDS)
8762 }
8763
8764 #[allow(unused_variables)]
8765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8766 where
8767 E: serde::de::Error,
8768 {
8769 match value {
8770 "status" => Ok(GeneratedField::Status),
8771 "version" => Ok(GeneratedField::Version),
8772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8773 }
8774 }
8775 }
8776 deserializer.deserialize_identifier(GeneratedVisitor)
8777 }
8778 }
8779 struct GeneratedVisitor;
8780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8781 type Value = DropFunctionResponse;
8782
8783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8784 formatter.write_str("struct ddl_service.DropFunctionResponse")
8785 }
8786
8787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
8788 where
8789 V: serde::de::MapAccess<'de>,
8790 {
8791 let mut status__ = None;
8792 let mut version__ = None;
8793 while let Some(k) = map_.next_key()? {
8794 match k {
8795 GeneratedField::Status => {
8796 if status__.is_some() {
8797 return Err(serde::de::Error::duplicate_field("status"));
8798 }
8799 status__ = map_.next_value()?;
8800 }
8801 GeneratedField::Version => {
8802 if version__.is_some() {
8803 return Err(serde::de::Error::duplicate_field("version"));
8804 }
8805 version__ = map_.next_value()?;
8806 }
8807 }
8808 }
8809 Ok(DropFunctionResponse {
8810 status: status__,
8811 version: version__,
8812 })
8813 }
8814 }
8815 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
8816 }
8817}
8818impl serde::Serialize for DropIndexRequest {
8819 #[allow(deprecated)]
8820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8821 where
8822 S: serde::Serializer,
8823 {
8824 use serde::ser::SerializeStruct;
8825 let mut len = 0;
8826 if self.index_id != 0 {
8827 len += 1;
8828 }
8829 if self.cascade {
8830 len += 1;
8831 }
8832 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
8833 if self.index_id != 0 {
8834 struct_ser.serialize_field("indexId", &self.index_id)?;
8835 }
8836 if self.cascade {
8837 struct_ser.serialize_field("cascade", &self.cascade)?;
8838 }
8839 struct_ser.end()
8840 }
8841}
8842impl<'de> serde::Deserialize<'de> for DropIndexRequest {
8843 #[allow(deprecated)]
8844 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8845 where
8846 D: serde::Deserializer<'de>,
8847 {
8848 const FIELDS: &[&str] = &[
8849 "index_id",
8850 "indexId",
8851 "cascade",
8852 ];
8853
8854 #[allow(clippy::enum_variant_names)]
8855 enum GeneratedField {
8856 IndexId,
8857 Cascade,
8858 }
8859 impl<'de> serde::Deserialize<'de> for GeneratedField {
8860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8861 where
8862 D: serde::Deserializer<'de>,
8863 {
8864 struct GeneratedVisitor;
8865
8866 impl serde::de::Visitor<'_> for GeneratedVisitor {
8867 type Value = GeneratedField;
8868
8869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8870 write!(formatter, "expected one of: {:?}", &FIELDS)
8871 }
8872
8873 #[allow(unused_variables)]
8874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8875 where
8876 E: serde::de::Error,
8877 {
8878 match value {
8879 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8880 "cascade" => Ok(GeneratedField::Cascade),
8881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8882 }
8883 }
8884 }
8885 deserializer.deserialize_identifier(GeneratedVisitor)
8886 }
8887 }
8888 struct GeneratedVisitor;
8889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8890 type Value = DropIndexRequest;
8891
8892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8893 formatter.write_str("struct ddl_service.DropIndexRequest")
8894 }
8895
8896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8897 where
8898 V: serde::de::MapAccess<'de>,
8899 {
8900 let mut index_id__ = None;
8901 let mut cascade__ = None;
8902 while let Some(k) = map_.next_key()? {
8903 match k {
8904 GeneratedField::IndexId => {
8905 if index_id__.is_some() {
8906 return Err(serde::de::Error::duplicate_field("indexId"));
8907 }
8908 index_id__ =
8909 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8910 ;
8911 }
8912 GeneratedField::Cascade => {
8913 if cascade__.is_some() {
8914 return Err(serde::de::Error::duplicate_field("cascade"));
8915 }
8916 cascade__ = Some(map_.next_value()?);
8917 }
8918 }
8919 }
8920 Ok(DropIndexRequest {
8921 index_id: index_id__.unwrap_or_default(),
8922 cascade: cascade__.unwrap_or_default(),
8923 })
8924 }
8925 }
8926 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8927 }
8928}
8929impl serde::Serialize for DropIndexResponse {
8930 #[allow(deprecated)]
8931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8932 where
8933 S: serde::Serializer,
8934 {
8935 use serde::ser::SerializeStruct;
8936 let mut len = 0;
8937 if self.status.is_some() {
8938 len += 1;
8939 }
8940 if self.version.is_some() {
8941 len += 1;
8942 }
8943 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8944 if let Some(v) = self.status.as_ref() {
8945 struct_ser.serialize_field("status", v)?;
8946 }
8947 if let Some(v) = self.version.as_ref() {
8948 struct_ser.serialize_field("version", v)?;
8949 }
8950 struct_ser.end()
8951 }
8952}
8953impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8954 #[allow(deprecated)]
8955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8956 where
8957 D: serde::Deserializer<'de>,
8958 {
8959 const FIELDS: &[&str] = &[
8960 "status",
8961 "version",
8962 ];
8963
8964 #[allow(clippy::enum_variant_names)]
8965 enum GeneratedField {
8966 Status,
8967 Version,
8968 }
8969 impl<'de> serde::Deserialize<'de> for GeneratedField {
8970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8971 where
8972 D: serde::Deserializer<'de>,
8973 {
8974 struct GeneratedVisitor;
8975
8976 impl serde::de::Visitor<'_> for GeneratedVisitor {
8977 type Value = GeneratedField;
8978
8979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8980 write!(formatter, "expected one of: {:?}", &FIELDS)
8981 }
8982
8983 #[allow(unused_variables)]
8984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8985 where
8986 E: serde::de::Error,
8987 {
8988 match value {
8989 "status" => Ok(GeneratedField::Status),
8990 "version" => Ok(GeneratedField::Version),
8991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8992 }
8993 }
8994 }
8995 deserializer.deserialize_identifier(GeneratedVisitor)
8996 }
8997 }
8998 struct GeneratedVisitor;
8999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9000 type Value = DropIndexResponse;
9001
9002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9003 formatter.write_str("struct ddl_service.DropIndexResponse")
9004 }
9005
9006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
9007 where
9008 V: serde::de::MapAccess<'de>,
9009 {
9010 let mut status__ = None;
9011 let mut version__ = None;
9012 while let Some(k) = map_.next_key()? {
9013 match k {
9014 GeneratedField::Status => {
9015 if status__.is_some() {
9016 return Err(serde::de::Error::duplicate_field("status"));
9017 }
9018 status__ = map_.next_value()?;
9019 }
9020 GeneratedField::Version => {
9021 if version__.is_some() {
9022 return Err(serde::de::Error::duplicate_field("version"));
9023 }
9024 version__ = map_.next_value()?;
9025 }
9026 }
9027 }
9028 Ok(DropIndexResponse {
9029 status: status__,
9030 version: version__,
9031 })
9032 }
9033 }
9034 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
9035 }
9036}
9037impl serde::Serialize for DropMaterializedViewRequest {
9038 #[allow(deprecated)]
9039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9040 where
9041 S: serde::Serializer,
9042 {
9043 use serde::ser::SerializeStruct;
9044 let mut len = 0;
9045 if self.table_id != 0 {
9046 len += 1;
9047 }
9048 if self.cascade {
9049 len += 1;
9050 }
9051 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
9052 if self.table_id != 0 {
9053 struct_ser.serialize_field("tableId", &self.table_id)?;
9054 }
9055 if self.cascade {
9056 struct_ser.serialize_field("cascade", &self.cascade)?;
9057 }
9058 struct_ser.end()
9059 }
9060}
9061impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
9062 #[allow(deprecated)]
9063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9064 where
9065 D: serde::Deserializer<'de>,
9066 {
9067 const FIELDS: &[&str] = &[
9068 "table_id",
9069 "tableId",
9070 "cascade",
9071 ];
9072
9073 #[allow(clippy::enum_variant_names)]
9074 enum GeneratedField {
9075 TableId,
9076 Cascade,
9077 }
9078 impl<'de> serde::Deserialize<'de> for GeneratedField {
9079 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9080 where
9081 D: serde::Deserializer<'de>,
9082 {
9083 struct GeneratedVisitor;
9084
9085 impl serde::de::Visitor<'_> for GeneratedVisitor {
9086 type Value = GeneratedField;
9087
9088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9089 write!(formatter, "expected one of: {:?}", &FIELDS)
9090 }
9091
9092 #[allow(unused_variables)]
9093 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9094 where
9095 E: serde::de::Error,
9096 {
9097 match value {
9098 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9099 "cascade" => Ok(GeneratedField::Cascade),
9100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9101 }
9102 }
9103 }
9104 deserializer.deserialize_identifier(GeneratedVisitor)
9105 }
9106 }
9107 struct GeneratedVisitor;
9108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9109 type Value = DropMaterializedViewRequest;
9110
9111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9112 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
9113 }
9114
9115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
9116 where
9117 V: serde::de::MapAccess<'de>,
9118 {
9119 let mut table_id__ = None;
9120 let mut cascade__ = None;
9121 while let Some(k) = map_.next_key()? {
9122 match k {
9123 GeneratedField::TableId => {
9124 if table_id__.is_some() {
9125 return Err(serde::de::Error::duplicate_field("tableId"));
9126 }
9127 table_id__ =
9128 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9129 ;
9130 }
9131 GeneratedField::Cascade => {
9132 if cascade__.is_some() {
9133 return Err(serde::de::Error::duplicate_field("cascade"));
9134 }
9135 cascade__ = Some(map_.next_value()?);
9136 }
9137 }
9138 }
9139 Ok(DropMaterializedViewRequest {
9140 table_id: table_id__.unwrap_or_default(),
9141 cascade: cascade__.unwrap_or_default(),
9142 })
9143 }
9144 }
9145 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
9146 }
9147}
9148impl serde::Serialize for DropMaterializedViewResponse {
9149 #[allow(deprecated)]
9150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9151 where
9152 S: serde::Serializer,
9153 {
9154 use serde::ser::SerializeStruct;
9155 let mut len = 0;
9156 if self.status.is_some() {
9157 len += 1;
9158 }
9159 if self.version.is_some() {
9160 len += 1;
9161 }
9162 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
9163 if let Some(v) = self.status.as_ref() {
9164 struct_ser.serialize_field("status", v)?;
9165 }
9166 if let Some(v) = self.version.as_ref() {
9167 struct_ser.serialize_field("version", v)?;
9168 }
9169 struct_ser.end()
9170 }
9171}
9172impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
9173 #[allow(deprecated)]
9174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9175 where
9176 D: serde::Deserializer<'de>,
9177 {
9178 const FIELDS: &[&str] = &[
9179 "status",
9180 "version",
9181 ];
9182
9183 #[allow(clippy::enum_variant_names)]
9184 enum GeneratedField {
9185 Status,
9186 Version,
9187 }
9188 impl<'de> serde::Deserialize<'de> for GeneratedField {
9189 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9190 where
9191 D: serde::Deserializer<'de>,
9192 {
9193 struct GeneratedVisitor;
9194
9195 impl serde::de::Visitor<'_> for GeneratedVisitor {
9196 type Value = GeneratedField;
9197
9198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9199 write!(formatter, "expected one of: {:?}", &FIELDS)
9200 }
9201
9202 #[allow(unused_variables)]
9203 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9204 where
9205 E: serde::de::Error,
9206 {
9207 match value {
9208 "status" => Ok(GeneratedField::Status),
9209 "version" => Ok(GeneratedField::Version),
9210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9211 }
9212 }
9213 }
9214 deserializer.deserialize_identifier(GeneratedVisitor)
9215 }
9216 }
9217 struct GeneratedVisitor;
9218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9219 type Value = DropMaterializedViewResponse;
9220
9221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9222 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
9223 }
9224
9225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
9226 where
9227 V: serde::de::MapAccess<'de>,
9228 {
9229 let mut status__ = None;
9230 let mut version__ = None;
9231 while let Some(k) = map_.next_key()? {
9232 match k {
9233 GeneratedField::Status => {
9234 if status__.is_some() {
9235 return Err(serde::de::Error::duplicate_field("status"));
9236 }
9237 status__ = map_.next_value()?;
9238 }
9239 GeneratedField::Version => {
9240 if version__.is_some() {
9241 return Err(serde::de::Error::duplicate_field("version"));
9242 }
9243 version__ = map_.next_value()?;
9244 }
9245 }
9246 }
9247 Ok(DropMaterializedViewResponse {
9248 status: status__,
9249 version: version__,
9250 })
9251 }
9252 }
9253 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
9254 }
9255}
9256impl serde::Serialize for DropSchemaRequest {
9257 #[allow(deprecated)]
9258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9259 where
9260 S: serde::Serializer,
9261 {
9262 use serde::ser::SerializeStruct;
9263 let mut len = 0;
9264 if self.schema_id != 0 {
9265 len += 1;
9266 }
9267 if self.cascade {
9268 len += 1;
9269 }
9270 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
9271 if self.schema_id != 0 {
9272 struct_ser.serialize_field("schemaId", &self.schema_id)?;
9273 }
9274 if self.cascade {
9275 struct_ser.serialize_field("cascade", &self.cascade)?;
9276 }
9277 struct_ser.end()
9278 }
9279}
9280impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
9281 #[allow(deprecated)]
9282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9283 where
9284 D: serde::Deserializer<'de>,
9285 {
9286 const FIELDS: &[&str] = &[
9287 "schema_id",
9288 "schemaId",
9289 "cascade",
9290 ];
9291
9292 #[allow(clippy::enum_variant_names)]
9293 enum GeneratedField {
9294 SchemaId,
9295 Cascade,
9296 }
9297 impl<'de> serde::Deserialize<'de> for GeneratedField {
9298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9299 where
9300 D: serde::Deserializer<'de>,
9301 {
9302 struct GeneratedVisitor;
9303
9304 impl serde::de::Visitor<'_> for GeneratedVisitor {
9305 type Value = GeneratedField;
9306
9307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9308 write!(formatter, "expected one of: {:?}", &FIELDS)
9309 }
9310
9311 #[allow(unused_variables)]
9312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9313 where
9314 E: serde::de::Error,
9315 {
9316 match value {
9317 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
9318 "cascade" => Ok(GeneratedField::Cascade),
9319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9320 }
9321 }
9322 }
9323 deserializer.deserialize_identifier(GeneratedVisitor)
9324 }
9325 }
9326 struct GeneratedVisitor;
9327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9328 type Value = DropSchemaRequest;
9329
9330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9331 formatter.write_str("struct ddl_service.DropSchemaRequest")
9332 }
9333
9334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
9335 where
9336 V: serde::de::MapAccess<'de>,
9337 {
9338 let mut schema_id__ = None;
9339 let mut cascade__ = None;
9340 while let Some(k) = map_.next_key()? {
9341 match k {
9342 GeneratedField::SchemaId => {
9343 if schema_id__.is_some() {
9344 return Err(serde::de::Error::duplicate_field("schemaId"));
9345 }
9346 schema_id__ =
9347 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9348 ;
9349 }
9350 GeneratedField::Cascade => {
9351 if cascade__.is_some() {
9352 return Err(serde::de::Error::duplicate_field("cascade"));
9353 }
9354 cascade__ = Some(map_.next_value()?);
9355 }
9356 }
9357 }
9358 Ok(DropSchemaRequest {
9359 schema_id: schema_id__.unwrap_or_default(),
9360 cascade: cascade__.unwrap_or_default(),
9361 })
9362 }
9363 }
9364 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
9365 }
9366}
9367impl serde::Serialize for DropSchemaResponse {
9368 #[allow(deprecated)]
9369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9370 where
9371 S: serde::Serializer,
9372 {
9373 use serde::ser::SerializeStruct;
9374 let mut len = 0;
9375 if self.status.is_some() {
9376 len += 1;
9377 }
9378 if self.version.is_some() {
9379 len += 1;
9380 }
9381 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
9382 if let Some(v) = self.status.as_ref() {
9383 struct_ser.serialize_field("status", v)?;
9384 }
9385 if let Some(v) = self.version.as_ref() {
9386 struct_ser.serialize_field("version", v)?;
9387 }
9388 struct_ser.end()
9389 }
9390}
9391impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
9392 #[allow(deprecated)]
9393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9394 where
9395 D: serde::Deserializer<'de>,
9396 {
9397 const FIELDS: &[&str] = &[
9398 "status",
9399 "version",
9400 ];
9401
9402 #[allow(clippy::enum_variant_names)]
9403 enum GeneratedField {
9404 Status,
9405 Version,
9406 }
9407 impl<'de> serde::Deserialize<'de> for GeneratedField {
9408 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9409 where
9410 D: serde::Deserializer<'de>,
9411 {
9412 struct GeneratedVisitor;
9413
9414 impl serde::de::Visitor<'_> for GeneratedVisitor {
9415 type Value = GeneratedField;
9416
9417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9418 write!(formatter, "expected one of: {:?}", &FIELDS)
9419 }
9420
9421 #[allow(unused_variables)]
9422 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9423 where
9424 E: serde::de::Error,
9425 {
9426 match value {
9427 "status" => Ok(GeneratedField::Status),
9428 "version" => Ok(GeneratedField::Version),
9429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9430 }
9431 }
9432 }
9433 deserializer.deserialize_identifier(GeneratedVisitor)
9434 }
9435 }
9436 struct GeneratedVisitor;
9437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9438 type Value = DropSchemaResponse;
9439
9440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9441 formatter.write_str("struct ddl_service.DropSchemaResponse")
9442 }
9443
9444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
9445 where
9446 V: serde::de::MapAccess<'de>,
9447 {
9448 let mut status__ = None;
9449 let mut version__ = None;
9450 while let Some(k) = map_.next_key()? {
9451 match k {
9452 GeneratedField::Status => {
9453 if status__.is_some() {
9454 return Err(serde::de::Error::duplicate_field("status"));
9455 }
9456 status__ = map_.next_value()?;
9457 }
9458 GeneratedField::Version => {
9459 if version__.is_some() {
9460 return Err(serde::de::Error::duplicate_field("version"));
9461 }
9462 version__ = map_.next_value()?;
9463 }
9464 }
9465 }
9466 Ok(DropSchemaResponse {
9467 status: status__,
9468 version: version__,
9469 })
9470 }
9471 }
9472 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
9473 }
9474}
9475impl serde::Serialize for DropSecretRequest {
9476 #[allow(deprecated)]
9477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9478 where
9479 S: serde::Serializer,
9480 {
9481 use serde::ser::SerializeStruct;
9482 let mut len = 0;
9483 if self.secret_id != 0 {
9484 len += 1;
9485 }
9486 if self.cascade {
9487 len += 1;
9488 }
9489 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
9490 if self.secret_id != 0 {
9491 struct_ser.serialize_field("secretId", &self.secret_id)?;
9492 }
9493 if self.cascade {
9494 struct_ser.serialize_field("cascade", &self.cascade)?;
9495 }
9496 struct_ser.end()
9497 }
9498}
9499impl<'de> serde::Deserialize<'de> for DropSecretRequest {
9500 #[allow(deprecated)]
9501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9502 where
9503 D: serde::Deserializer<'de>,
9504 {
9505 const FIELDS: &[&str] = &[
9506 "secret_id",
9507 "secretId",
9508 "cascade",
9509 ];
9510
9511 #[allow(clippy::enum_variant_names)]
9512 enum GeneratedField {
9513 SecretId,
9514 Cascade,
9515 }
9516 impl<'de> serde::Deserialize<'de> for GeneratedField {
9517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9518 where
9519 D: serde::Deserializer<'de>,
9520 {
9521 struct GeneratedVisitor;
9522
9523 impl serde::de::Visitor<'_> for GeneratedVisitor {
9524 type Value = GeneratedField;
9525
9526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9527 write!(formatter, "expected one of: {:?}", &FIELDS)
9528 }
9529
9530 #[allow(unused_variables)]
9531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9532 where
9533 E: serde::de::Error,
9534 {
9535 match value {
9536 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
9537 "cascade" => Ok(GeneratedField::Cascade),
9538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9539 }
9540 }
9541 }
9542 deserializer.deserialize_identifier(GeneratedVisitor)
9543 }
9544 }
9545 struct GeneratedVisitor;
9546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9547 type Value = DropSecretRequest;
9548
9549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9550 formatter.write_str("struct ddl_service.DropSecretRequest")
9551 }
9552
9553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
9554 where
9555 V: serde::de::MapAccess<'de>,
9556 {
9557 let mut secret_id__ = None;
9558 let mut cascade__ = None;
9559 while let Some(k) = map_.next_key()? {
9560 match k {
9561 GeneratedField::SecretId => {
9562 if secret_id__.is_some() {
9563 return Err(serde::de::Error::duplicate_field("secretId"));
9564 }
9565 secret_id__ =
9566 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9567 ;
9568 }
9569 GeneratedField::Cascade => {
9570 if cascade__.is_some() {
9571 return Err(serde::de::Error::duplicate_field("cascade"));
9572 }
9573 cascade__ = Some(map_.next_value()?);
9574 }
9575 }
9576 }
9577 Ok(DropSecretRequest {
9578 secret_id: secret_id__.unwrap_or_default(),
9579 cascade: cascade__.unwrap_or_default(),
9580 })
9581 }
9582 }
9583 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
9584 }
9585}
9586impl serde::Serialize for DropSecretResponse {
9587 #[allow(deprecated)]
9588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9589 where
9590 S: serde::Serializer,
9591 {
9592 use serde::ser::SerializeStruct;
9593 let mut len = 0;
9594 if self.version.is_some() {
9595 len += 1;
9596 }
9597 if self.status.is_some() {
9598 len += 1;
9599 }
9600 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
9601 if let Some(v) = self.version.as_ref() {
9602 struct_ser.serialize_field("version", v)?;
9603 }
9604 if let Some(v) = self.status.as_ref() {
9605 struct_ser.serialize_field("status", v)?;
9606 }
9607 struct_ser.end()
9608 }
9609}
9610impl<'de> serde::Deserialize<'de> for DropSecretResponse {
9611 #[allow(deprecated)]
9612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9613 where
9614 D: serde::Deserializer<'de>,
9615 {
9616 const FIELDS: &[&str] = &[
9617 "version",
9618 "status",
9619 ];
9620
9621 #[allow(clippy::enum_variant_names)]
9622 enum GeneratedField {
9623 Version,
9624 Status,
9625 }
9626 impl<'de> serde::Deserialize<'de> for GeneratedField {
9627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9628 where
9629 D: serde::Deserializer<'de>,
9630 {
9631 struct GeneratedVisitor;
9632
9633 impl serde::de::Visitor<'_> for GeneratedVisitor {
9634 type Value = GeneratedField;
9635
9636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9637 write!(formatter, "expected one of: {:?}", &FIELDS)
9638 }
9639
9640 #[allow(unused_variables)]
9641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9642 where
9643 E: serde::de::Error,
9644 {
9645 match value {
9646 "version" => Ok(GeneratedField::Version),
9647 "status" => Ok(GeneratedField::Status),
9648 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9649 }
9650 }
9651 }
9652 deserializer.deserialize_identifier(GeneratedVisitor)
9653 }
9654 }
9655 struct GeneratedVisitor;
9656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9657 type Value = DropSecretResponse;
9658
9659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9660 formatter.write_str("struct ddl_service.DropSecretResponse")
9661 }
9662
9663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
9664 where
9665 V: serde::de::MapAccess<'de>,
9666 {
9667 let mut version__ = None;
9668 let mut status__ = None;
9669 while let Some(k) = map_.next_key()? {
9670 match k {
9671 GeneratedField::Version => {
9672 if version__.is_some() {
9673 return Err(serde::de::Error::duplicate_field("version"));
9674 }
9675 version__ = map_.next_value()?;
9676 }
9677 GeneratedField::Status => {
9678 if status__.is_some() {
9679 return Err(serde::de::Error::duplicate_field("status"));
9680 }
9681 status__ = map_.next_value()?;
9682 }
9683 }
9684 }
9685 Ok(DropSecretResponse {
9686 version: version__,
9687 status: status__,
9688 })
9689 }
9690 }
9691 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
9692 }
9693}
9694impl serde::Serialize for DropSinkRequest {
9695 #[allow(deprecated)]
9696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9697 where
9698 S: serde::Serializer,
9699 {
9700 use serde::ser::SerializeStruct;
9701 let mut len = 0;
9702 if self.sink_id != 0 {
9703 len += 1;
9704 }
9705 if self.cascade {
9706 len += 1;
9707 }
9708 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
9709 if self.sink_id != 0 {
9710 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9711 }
9712 if self.cascade {
9713 struct_ser.serialize_field("cascade", &self.cascade)?;
9714 }
9715 struct_ser.end()
9716 }
9717}
9718impl<'de> serde::Deserialize<'de> for DropSinkRequest {
9719 #[allow(deprecated)]
9720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9721 where
9722 D: serde::Deserializer<'de>,
9723 {
9724 const FIELDS: &[&str] = &[
9725 "sink_id",
9726 "sinkId",
9727 "cascade",
9728 ];
9729
9730 #[allow(clippy::enum_variant_names)]
9731 enum GeneratedField {
9732 SinkId,
9733 Cascade,
9734 }
9735 impl<'de> serde::Deserialize<'de> for GeneratedField {
9736 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9737 where
9738 D: serde::Deserializer<'de>,
9739 {
9740 struct GeneratedVisitor;
9741
9742 impl serde::de::Visitor<'_> for GeneratedVisitor {
9743 type Value = GeneratedField;
9744
9745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9746 write!(formatter, "expected one of: {:?}", &FIELDS)
9747 }
9748
9749 #[allow(unused_variables)]
9750 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9751 where
9752 E: serde::de::Error,
9753 {
9754 match value {
9755 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9756 "cascade" => Ok(GeneratedField::Cascade),
9757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9758 }
9759 }
9760 }
9761 deserializer.deserialize_identifier(GeneratedVisitor)
9762 }
9763 }
9764 struct GeneratedVisitor;
9765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9766 type Value = DropSinkRequest;
9767
9768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9769 formatter.write_str("struct ddl_service.DropSinkRequest")
9770 }
9771
9772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
9773 where
9774 V: serde::de::MapAccess<'de>,
9775 {
9776 let mut sink_id__ = None;
9777 let mut cascade__ = None;
9778 while let Some(k) = map_.next_key()? {
9779 match k {
9780 GeneratedField::SinkId => {
9781 if sink_id__.is_some() {
9782 return Err(serde::de::Error::duplicate_field("sinkId"));
9783 }
9784 sink_id__ =
9785 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9786 ;
9787 }
9788 GeneratedField::Cascade => {
9789 if cascade__.is_some() {
9790 return Err(serde::de::Error::duplicate_field("cascade"));
9791 }
9792 cascade__ = Some(map_.next_value()?);
9793 }
9794 }
9795 }
9796 Ok(DropSinkRequest {
9797 sink_id: sink_id__.unwrap_or_default(),
9798 cascade: cascade__.unwrap_or_default(),
9799 })
9800 }
9801 }
9802 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
9803 }
9804}
9805impl serde::Serialize for DropSinkResponse {
9806 #[allow(deprecated)]
9807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9808 where
9809 S: serde::Serializer,
9810 {
9811 use serde::ser::SerializeStruct;
9812 let mut len = 0;
9813 if self.status.is_some() {
9814 len += 1;
9815 }
9816 if self.version.is_some() {
9817 len += 1;
9818 }
9819 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
9820 if let Some(v) = self.status.as_ref() {
9821 struct_ser.serialize_field("status", v)?;
9822 }
9823 if let Some(v) = self.version.as_ref() {
9824 struct_ser.serialize_field("version", v)?;
9825 }
9826 struct_ser.end()
9827 }
9828}
9829impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9830 #[allow(deprecated)]
9831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9832 where
9833 D: serde::Deserializer<'de>,
9834 {
9835 const FIELDS: &[&str] = &[
9836 "status",
9837 "version",
9838 ];
9839
9840 #[allow(clippy::enum_variant_names)]
9841 enum GeneratedField {
9842 Status,
9843 Version,
9844 }
9845 impl<'de> serde::Deserialize<'de> for GeneratedField {
9846 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9847 where
9848 D: serde::Deserializer<'de>,
9849 {
9850 struct GeneratedVisitor;
9851
9852 impl serde::de::Visitor<'_> for GeneratedVisitor {
9853 type Value = GeneratedField;
9854
9855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9856 write!(formatter, "expected one of: {:?}", &FIELDS)
9857 }
9858
9859 #[allow(unused_variables)]
9860 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9861 where
9862 E: serde::de::Error,
9863 {
9864 match value {
9865 "status" => Ok(GeneratedField::Status),
9866 "version" => Ok(GeneratedField::Version),
9867 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9868 }
9869 }
9870 }
9871 deserializer.deserialize_identifier(GeneratedVisitor)
9872 }
9873 }
9874 struct GeneratedVisitor;
9875 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9876 type Value = DropSinkResponse;
9877
9878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9879 formatter.write_str("struct ddl_service.DropSinkResponse")
9880 }
9881
9882 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9883 where
9884 V: serde::de::MapAccess<'de>,
9885 {
9886 let mut status__ = None;
9887 let mut version__ = None;
9888 while let Some(k) = map_.next_key()? {
9889 match k {
9890 GeneratedField::Status => {
9891 if status__.is_some() {
9892 return Err(serde::de::Error::duplicate_field("status"));
9893 }
9894 status__ = map_.next_value()?;
9895 }
9896 GeneratedField::Version => {
9897 if version__.is_some() {
9898 return Err(serde::de::Error::duplicate_field("version"));
9899 }
9900 version__ = map_.next_value()?;
9901 }
9902 }
9903 }
9904 Ok(DropSinkResponse {
9905 status: status__,
9906 version: version__,
9907 })
9908 }
9909 }
9910 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9911 }
9912}
9913impl serde::Serialize for DropSourceRequest {
9914 #[allow(deprecated)]
9915 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9916 where
9917 S: serde::Serializer,
9918 {
9919 use serde::ser::SerializeStruct;
9920 let mut len = 0;
9921 if self.source_id != 0 {
9922 len += 1;
9923 }
9924 if self.cascade {
9925 len += 1;
9926 }
9927 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9928 if self.source_id != 0 {
9929 struct_ser.serialize_field("sourceId", &self.source_id)?;
9930 }
9931 if self.cascade {
9932 struct_ser.serialize_field("cascade", &self.cascade)?;
9933 }
9934 struct_ser.end()
9935 }
9936}
9937impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9938 #[allow(deprecated)]
9939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9940 where
9941 D: serde::Deserializer<'de>,
9942 {
9943 const FIELDS: &[&str] = &[
9944 "source_id",
9945 "sourceId",
9946 "cascade",
9947 ];
9948
9949 #[allow(clippy::enum_variant_names)]
9950 enum GeneratedField {
9951 SourceId,
9952 Cascade,
9953 }
9954 impl<'de> serde::Deserialize<'de> for GeneratedField {
9955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9956 where
9957 D: serde::Deserializer<'de>,
9958 {
9959 struct GeneratedVisitor;
9960
9961 impl serde::de::Visitor<'_> for GeneratedVisitor {
9962 type Value = GeneratedField;
9963
9964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9965 write!(formatter, "expected one of: {:?}", &FIELDS)
9966 }
9967
9968 #[allow(unused_variables)]
9969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9970 where
9971 E: serde::de::Error,
9972 {
9973 match value {
9974 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9975 "cascade" => Ok(GeneratedField::Cascade),
9976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9977 }
9978 }
9979 }
9980 deserializer.deserialize_identifier(GeneratedVisitor)
9981 }
9982 }
9983 struct GeneratedVisitor;
9984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9985 type Value = DropSourceRequest;
9986
9987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9988 formatter.write_str("struct ddl_service.DropSourceRequest")
9989 }
9990
9991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9992 where
9993 V: serde::de::MapAccess<'de>,
9994 {
9995 let mut source_id__ = None;
9996 let mut cascade__ = None;
9997 while let Some(k) = map_.next_key()? {
9998 match k {
9999 GeneratedField::SourceId => {
10000 if source_id__.is_some() {
10001 return Err(serde::de::Error::duplicate_field("sourceId"));
10002 }
10003 source_id__ =
10004 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10005 ;
10006 }
10007 GeneratedField::Cascade => {
10008 if cascade__.is_some() {
10009 return Err(serde::de::Error::duplicate_field("cascade"));
10010 }
10011 cascade__ = Some(map_.next_value()?);
10012 }
10013 }
10014 }
10015 Ok(DropSourceRequest {
10016 source_id: source_id__.unwrap_or_default(),
10017 cascade: cascade__.unwrap_or_default(),
10018 })
10019 }
10020 }
10021 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
10022 }
10023}
10024impl serde::Serialize for DropSourceResponse {
10025 #[allow(deprecated)]
10026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10027 where
10028 S: serde::Serializer,
10029 {
10030 use serde::ser::SerializeStruct;
10031 let mut len = 0;
10032 if self.status.is_some() {
10033 len += 1;
10034 }
10035 if self.version.is_some() {
10036 len += 1;
10037 }
10038 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
10039 if let Some(v) = self.status.as_ref() {
10040 struct_ser.serialize_field("status", v)?;
10041 }
10042 if let Some(v) = self.version.as_ref() {
10043 struct_ser.serialize_field("version", v)?;
10044 }
10045 struct_ser.end()
10046 }
10047}
10048impl<'de> serde::Deserialize<'de> for DropSourceResponse {
10049 #[allow(deprecated)]
10050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10051 where
10052 D: serde::Deserializer<'de>,
10053 {
10054 const FIELDS: &[&str] = &[
10055 "status",
10056 "version",
10057 ];
10058
10059 #[allow(clippy::enum_variant_names)]
10060 enum GeneratedField {
10061 Status,
10062 Version,
10063 }
10064 impl<'de> serde::Deserialize<'de> for GeneratedField {
10065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10066 where
10067 D: serde::Deserializer<'de>,
10068 {
10069 struct GeneratedVisitor;
10070
10071 impl serde::de::Visitor<'_> for GeneratedVisitor {
10072 type Value = GeneratedField;
10073
10074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10075 write!(formatter, "expected one of: {:?}", &FIELDS)
10076 }
10077
10078 #[allow(unused_variables)]
10079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10080 where
10081 E: serde::de::Error,
10082 {
10083 match value {
10084 "status" => Ok(GeneratedField::Status),
10085 "version" => Ok(GeneratedField::Version),
10086 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10087 }
10088 }
10089 }
10090 deserializer.deserialize_identifier(GeneratedVisitor)
10091 }
10092 }
10093 struct GeneratedVisitor;
10094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10095 type Value = DropSourceResponse;
10096
10097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10098 formatter.write_str("struct ddl_service.DropSourceResponse")
10099 }
10100
10101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
10102 where
10103 V: serde::de::MapAccess<'de>,
10104 {
10105 let mut status__ = None;
10106 let mut version__ = None;
10107 while let Some(k) = map_.next_key()? {
10108 match k {
10109 GeneratedField::Status => {
10110 if status__.is_some() {
10111 return Err(serde::de::Error::duplicate_field("status"));
10112 }
10113 status__ = map_.next_value()?;
10114 }
10115 GeneratedField::Version => {
10116 if version__.is_some() {
10117 return Err(serde::de::Error::duplicate_field("version"));
10118 }
10119 version__ = map_.next_value()?;
10120 }
10121 }
10122 }
10123 Ok(DropSourceResponse {
10124 status: status__,
10125 version: version__,
10126 })
10127 }
10128 }
10129 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
10130 }
10131}
10132impl serde::Serialize for DropSubscriptionRequest {
10133 #[allow(deprecated)]
10134 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10135 where
10136 S: serde::Serializer,
10137 {
10138 use serde::ser::SerializeStruct;
10139 let mut len = 0;
10140 if self.subscription_id != 0 {
10141 len += 1;
10142 }
10143 if self.cascade {
10144 len += 1;
10145 }
10146 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
10147 if self.subscription_id != 0 {
10148 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
10149 }
10150 if self.cascade {
10151 struct_ser.serialize_field("cascade", &self.cascade)?;
10152 }
10153 struct_ser.end()
10154 }
10155}
10156impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
10157 #[allow(deprecated)]
10158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10159 where
10160 D: serde::Deserializer<'de>,
10161 {
10162 const FIELDS: &[&str] = &[
10163 "subscription_id",
10164 "subscriptionId",
10165 "cascade",
10166 ];
10167
10168 #[allow(clippy::enum_variant_names)]
10169 enum GeneratedField {
10170 SubscriptionId,
10171 Cascade,
10172 }
10173 impl<'de> serde::Deserialize<'de> for GeneratedField {
10174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10175 where
10176 D: serde::Deserializer<'de>,
10177 {
10178 struct GeneratedVisitor;
10179
10180 impl serde::de::Visitor<'_> for GeneratedVisitor {
10181 type Value = GeneratedField;
10182
10183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10184 write!(formatter, "expected one of: {:?}", &FIELDS)
10185 }
10186
10187 #[allow(unused_variables)]
10188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10189 where
10190 E: serde::de::Error,
10191 {
10192 match value {
10193 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
10194 "cascade" => Ok(GeneratedField::Cascade),
10195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10196 }
10197 }
10198 }
10199 deserializer.deserialize_identifier(GeneratedVisitor)
10200 }
10201 }
10202 struct GeneratedVisitor;
10203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10204 type Value = DropSubscriptionRequest;
10205
10206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10207 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
10208 }
10209
10210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
10211 where
10212 V: serde::de::MapAccess<'de>,
10213 {
10214 let mut subscription_id__ = None;
10215 let mut cascade__ = None;
10216 while let Some(k) = map_.next_key()? {
10217 match k {
10218 GeneratedField::SubscriptionId => {
10219 if subscription_id__.is_some() {
10220 return Err(serde::de::Error::duplicate_field("subscriptionId"));
10221 }
10222 subscription_id__ =
10223 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10224 ;
10225 }
10226 GeneratedField::Cascade => {
10227 if cascade__.is_some() {
10228 return Err(serde::de::Error::duplicate_field("cascade"));
10229 }
10230 cascade__ = Some(map_.next_value()?);
10231 }
10232 }
10233 }
10234 Ok(DropSubscriptionRequest {
10235 subscription_id: subscription_id__.unwrap_or_default(),
10236 cascade: cascade__.unwrap_or_default(),
10237 })
10238 }
10239 }
10240 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
10241 }
10242}
10243impl serde::Serialize for DropSubscriptionResponse {
10244 #[allow(deprecated)]
10245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10246 where
10247 S: serde::Serializer,
10248 {
10249 use serde::ser::SerializeStruct;
10250 let mut len = 0;
10251 if self.status.is_some() {
10252 len += 1;
10253 }
10254 if self.version.is_some() {
10255 len += 1;
10256 }
10257 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
10258 if let Some(v) = self.status.as_ref() {
10259 struct_ser.serialize_field("status", v)?;
10260 }
10261 if let Some(v) = self.version.as_ref() {
10262 struct_ser.serialize_field("version", v)?;
10263 }
10264 struct_ser.end()
10265 }
10266}
10267impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
10268 #[allow(deprecated)]
10269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10270 where
10271 D: serde::Deserializer<'de>,
10272 {
10273 const FIELDS: &[&str] = &[
10274 "status",
10275 "version",
10276 ];
10277
10278 #[allow(clippy::enum_variant_names)]
10279 enum GeneratedField {
10280 Status,
10281 Version,
10282 }
10283 impl<'de> serde::Deserialize<'de> for GeneratedField {
10284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10285 where
10286 D: serde::Deserializer<'de>,
10287 {
10288 struct GeneratedVisitor;
10289
10290 impl serde::de::Visitor<'_> for GeneratedVisitor {
10291 type Value = GeneratedField;
10292
10293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294 write!(formatter, "expected one of: {:?}", &FIELDS)
10295 }
10296
10297 #[allow(unused_variables)]
10298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10299 where
10300 E: serde::de::Error,
10301 {
10302 match value {
10303 "status" => Ok(GeneratedField::Status),
10304 "version" => Ok(GeneratedField::Version),
10305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10306 }
10307 }
10308 }
10309 deserializer.deserialize_identifier(GeneratedVisitor)
10310 }
10311 }
10312 struct GeneratedVisitor;
10313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10314 type Value = DropSubscriptionResponse;
10315
10316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10317 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
10318 }
10319
10320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
10321 where
10322 V: serde::de::MapAccess<'de>,
10323 {
10324 let mut status__ = None;
10325 let mut version__ = None;
10326 while let Some(k) = map_.next_key()? {
10327 match k {
10328 GeneratedField::Status => {
10329 if status__.is_some() {
10330 return Err(serde::de::Error::duplicate_field("status"));
10331 }
10332 status__ = map_.next_value()?;
10333 }
10334 GeneratedField::Version => {
10335 if version__.is_some() {
10336 return Err(serde::de::Error::duplicate_field("version"));
10337 }
10338 version__ = map_.next_value()?;
10339 }
10340 }
10341 }
10342 Ok(DropSubscriptionResponse {
10343 status: status__,
10344 version: version__,
10345 })
10346 }
10347 }
10348 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
10349 }
10350}
10351impl serde::Serialize for DropTableRequest {
10352 #[allow(deprecated)]
10353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10354 where
10355 S: serde::Serializer,
10356 {
10357 use serde::ser::SerializeStruct;
10358 let mut len = 0;
10359 if self.table_id != 0 {
10360 len += 1;
10361 }
10362 if self.cascade {
10363 len += 1;
10364 }
10365 if self.source_id.is_some() {
10366 len += 1;
10367 }
10368 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
10369 if self.table_id != 0 {
10370 struct_ser.serialize_field("tableId", &self.table_id)?;
10371 }
10372 if self.cascade {
10373 struct_ser.serialize_field("cascade", &self.cascade)?;
10374 }
10375 if let Some(v) = self.source_id.as_ref() {
10376 match v {
10377 drop_table_request::SourceId::Id(v) => {
10378 struct_ser.serialize_field("id", v)?;
10379 }
10380 }
10381 }
10382 struct_ser.end()
10383 }
10384}
10385impl<'de> serde::Deserialize<'de> for DropTableRequest {
10386 #[allow(deprecated)]
10387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10388 where
10389 D: serde::Deserializer<'de>,
10390 {
10391 const FIELDS: &[&str] = &[
10392 "table_id",
10393 "tableId",
10394 "cascade",
10395 "id",
10396 ];
10397
10398 #[allow(clippy::enum_variant_names)]
10399 enum GeneratedField {
10400 TableId,
10401 Cascade,
10402 Id,
10403 }
10404 impl<'de> serde::Deserialize<'de> for GeneratedField {
10405 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10406 where
10407 D: serde::Deserializer<'de>,
10408 {
10409 struct GeneratedVisitor;
10410
10411 impl serde::de::Visitor<'_> for GeneratedVisitor {
10412 type Value = GeneratedField;
10413
10414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10415 write!(formatter, "expected one of: {:?}", &FIELDS)
10416 }
10417
10418 #[allow(unused_variables)]
10419 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10420 where
10421 E: serde::de::Error,
10422 {
10423 match value {
10424 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10425 "cascade" => Ok(GeneratedField::Cascade),
10426 "id" => Ok(GeneratedField::Id),
10427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10428 }
10429 }
10430 }
10431 deserializer.deserialize_identifier(GeneratedVisitor)
10432 }
10433 }
10434 struct GeneratedVisitor;
10435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10436 type Value = DropTableRequest;
10437
10438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10439 formatter.write_str("struct ddl_service.DropTableRequest")
10440 }
10441
10442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
10443 where
10444 V: serde::de::MapAccess<'de>,
10445 {
10446 let mut table_id__ = None;
10447 let mut cascade__ = None;
10448 let mut source_id__ = None;
10449 while let Some(k) = map_.next_key()? {
10450 match k {
10451 GeneratedField::TableId => {
10452 if table_id__.is_some() {
10453 return Err(serde::de::Error::duplicate_field("tableId"));
10454 }
10455 table_id__ =
10456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10457 ;
10458 }
10459 GeneratedField::Cascade => {
10460 if cascade__.is_some() {
10461 return Err(serde::de::Error::duplicate_field("cascade"));
10462 }
10463 cascade__ = Some(map_.next_value()?);
10464 }
10465 GeneratedField::Id => {
10466 if source_id__.is_some() {
10467 return Err(serde::de::Error::duplicate_field("id"));
10468 }
10469 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
10470 }
10471 }
10472 }
10473 Ok(DropTableRequest {
10474 table_id: table_id__.unwrap_or_default(),
10475 cascade: cascade__.unwrap_or_default(),
10476 source_id: source_id__,
10477 })
10478 }
10479 }
10480 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
10481 }
10482}
10483impl serde::Serialize for DropTableResponse {
10484 #[allow(deprecated)]
10485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10486 where
10487 S: serde::Serializer,
10488 {
10489 use serde::ser::SerializeStruct;
10490 let mut len = 0;
10491 if self.status.is_some() {
10492 len += 1;
10493 }
10494 if self.version.is_some() {
10495 len += 1;
10496 }
10497 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
10498 if let Some(v) = self.status.as_ref() {
10499 struct_ser.serialize_field("status", v)?;
10500 }
10501 if let Some(v) = self.version.as_ref() {
10502 struct_ser.serialize_field("version", v)?;
10503 }
10504 struct_ser.end()
10505 }
10506}
10507impl<'de> serde::Deserialize<'de> for DropTableResponse {
10508 #[allow(deprecated)]
10509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10510 where
10511 D: serde::Deserializer<'de>,
10512 {
10513 const FIELDS: &[&str] = &[
10514 "status",
10515 "version",
10516 ];
10517
10518 #[allow(clippy::enum_variant_names)]
10519 enum GeneratedField {
10520 Status,
10521 Version,
10522 }
10523 impl<'de> serde::Deserialize<'de> for GeneratedField {
10524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10525 where
10526 D: serde::Deserializer<'de>,
10527 {
10528 struct GeneratedVisitor;
10529
10530 impl serde::de::Visitor<'_> for GeneratedVisitor {
10531 type Value = GeneratedField;
10532
10533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10534 write!(formatter, "expected one of: {:?}", &FIELDS)
10535 }
10536
10537 #[allow(unused_variables)]
10538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10539 where
10540 E: serde::de::Error,
10541 {
10542 match value {
10543 "status" => Ok(GeneratedField::Status),
10544 "version" => Ok(GeneratedField::Version),
10545 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10546 }
10547 }
10548 }
10549 deserializer.deserialize_identifier(GeneratedVisitor)
10550 }
10551 }
10552 struct GeneratedVisitor;
10553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10554 type Value = DropTableResponse;
10555
10556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10557 formatter.write_str("struct ddl_service.DropTableResponse")
10558 }
10559
10560 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
10561 where
10562 V: serde::de::MapAccess<'de>,
10563 {
10564 let mut status__ = None;
10565 let mut version__ = None;
10566 while let Some(k) = map_.next_key()? {
10567 match k {
10568 GeneratedField::Status => {
10569 if status__.is_some() {
10570 return Err(serde::de::Error::duplicate_field("status"));
10571 }
10572 status__ = map_.next_value()?;
10573 }
10574 GeneratedField::Version => {
10575 if version__.is_some() {
10576 return Err(serde::de::Error::duplicate_field("version"));
10577 }
10578 version__ = map_.next_value()?;
10579 }
10580 }
10581 }
10582 Ok(DropTableResponse {
10583 status: status__,
10584 version: version__,
10585 })
10586 }
10587 }
10588 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
10589 }
10590}
10591impl serde::Serialize for DropViewRequest {
10592 #[allow(deprecated)]
10593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10594 where
10595 S: serde::Serializer,
10596 {
10597 use serde::ser::SerializeStruct;
10598 let mut len = 0;
10599 if self.view_id != 0 {
10600 len += 1;
10601 }
10602 if self.cascade {
10603 len += 1;
10604 }
10605 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
10606 if self.view_id != 0 {
10607 struct_ser.serialize_field("viewId", &self.view_id)?;
10608 }
10609 if self.cascade {
10610 struct_ser.serialize_field("cascade", &self.cascade)?;
10611 }
10612 struct_ser.end()
10613 }
10614}
10615impl<'de> serde::Deserialize<'de> for DropViewRequest {
10616 #[allow(deprecated)]
10617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10618 where
10619 D: serde::Deserializer<'de>,
10620 {
10621 const FIELDS: &[&str] = &[
10622 "view_id",
10623 "viewId",
10624 "cascade",
10625 ];
10626
10627 #[allow(clippy::enum_variant_names)]
10628 enum GeneratedField {
10629 ViewId,
10630 Cascade,
10631 }
10632 impl<'de> serde::Deserialize<'de> for GeneratedField {
10633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10634 where
10635 D: serde::Deserializer<'de>,
10636 {
10637 struct GeneratedVisitor;
10638
10639 impl serde::de::Visitor<'_> for GeneratedVisitor {
10640 type Value = GeneratedField;
10641
10642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10643 write!(formatter, "expected one of: {:?}", &FIELDS)
10644 }
10645
10646 #[allow(unused_variables)]
10647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10648 where
10649 E: serde::de::Error,
10650 {
10651 match value {
10652 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
10653 "cascade" => Ok(GeneratedField::Cascade),
10654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10655 }
10656 }
10657 }
10658 deserializer.deserialize_identifier(GeneratedVisitor)
10659 }
10660 }
10661 struct GeneratedVisitor;
10662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10663 type Value = DropViewRequest;
10664
10665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10666 formatter.write_str("struct ddl_service.DropViewRequest")
10667 }
10668
10669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
10670 where
10671 V: serde::de::MapAccess<'de>,
10672 {
10673 let mut view_id__ = None;
10674 let mut cascade__ = None;
10675 while let Some(k) = map_.next_key()? {
10676 match k {
10677 GeneratedField::ViewId => {
10678 if view_id__.is_some() {
10679 return Err(serde::de::Error::duplicate_field("viewId"));
10680 }
10681 view_id__ =
10682 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10683 ;
10684 }
10685 GeneratedField::Cascade => {
10686 if cascade__.is_some() {
10687 return Err(serde::de::Error::duplicate_field("cascade"));
10688 }
10689 cascade__ = Some(map_.next_value()?);
10690 }
10691 }
10692 }
10693 Ok(DropViewRequest {
10694 view_id: view_id__.unwrap_or_default(),
10695 cascade: cascade__.unwrap_or_default(),
10696 })
10697 }
10698 }
10699 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
10700 }
10701}
10702impl serde::Serialize for DropViewResponse {
10703 #[allow(deprecated)]
10704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10705 where
10706 S: serde::Serializer,
10707 {
10708 use serde::ser::SerializeStruct;
10709 let mut len = 0;
10710 if self.status.is_some() {
10711 len += 1;
10712 }
10713 if self.version.is_some() {
10714 len += 1;
10715 }
10716 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
10717 if let Some(v) = self.status.as_ref() {
10718 struct_ser.serialize_field("status", v)?;
10719 }
10720 if let Some(v) = self.version.as_ref() {
10721 struct_ser.serialize_field("version", v)?;
10722 }
10723 struct_ser.end()
10724 }
10725}
10726impl<'de> serde::Deserialize<'de> for DropViewResponse {
10727 #[allow(deprecated)]
10728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10729 where
10730 D: serde::Deserializer<'de>,
10731 {
10732 const FIELDS: &[&str] = &[
10733 "status",
10734 "version",
10735 ];
10736
10737 #[allow(clippy::enum_variant_names)]
10738 enum GeneratedField {
10739 Status,
10740 Version,
10741 }
10742 impl<'de> serde::Deserialize<'de> for GeneratedField {
10743 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10744 where
10745 D: serde::Deserializer<'de>,
10746 {
10747 struct GeneratedVisitor;
10748
10749 impl serde::de::Visitor<'_> for GeneratedVisitor {
10750 type Value = GeneratedField;
10751
10752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10753 write!(formatter, "expected one of: {:?}", &FIELDS)
10754 }
10755
10756 #[allow(unused_variables)]
10757 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10758 where
10759 E: serde::de::Error,
10760 {
10761 match value {
10762 "status" => Ok(GeneratedField::Status),
10763 "version" => Ok(GeneratedField::Version),
10764 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10765 }
10766 }
10767 }
10768 deserializer.deserialize_identifier(GeneratedVisitor)
10769 }
10770 }
10771 struct GeneratedVisitor;
10772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10773 type Value = DropViewResponse;
10774
10775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10776 formatter.write_str("struct ddl_service.DropViewResponse")
10777 }
10778
10779 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
10780 where
10781 V: serde::de::MapAccess<'de>,
10782 {
10783 let mut status__ = None;
10784 let mut version__ = None;
10785 while let Some(k) = map_.next_key()? {
10786 match k {
10787 GeneratedField::Status => {
10788 if status__.is_some() {
10789 return Err(serde::de::Error::duplicate_field("status"));
10790 }
10791 status__ = map_.next_value()?;
10792 }
10793 GeneratedField::Version => {
10794 if version__.is_some() {
10795 return Err(serde::de::Error::duplicate_field("version"));
10796 }
10797 version__ = map_.next_value()?;
10798 }
10799 }
10800 }
10801 Ok(DropViewResponse {
10802 status: status__,
10803 version: version__,
10804 })
10805 }
10806 }
10807 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
10808 }
10809}
10810impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
10811 #[allow(deprecated)]
10812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10813 where
10814 S: serde::Serializer,
10815 {
10816 use serde::ser::SerializeStruct;
10817 let mut len = 0;
10818 if self.sink_id != 0 {
10819 len += 1;
10820 }
10821 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
10822 if self.sink_id != 0 {
10823 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10824 }
10825 struct_ser.end()
10826 }
10827}
10828impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10829 #[allow(deprecated)]
10830 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10831 where
10832 D: serde::Deserializer<'de>,
10833 {
10834 const FIELDS: &[&str] = &[
10835 "sink_id",
10836 "sinkId",
10837 ];
10838
10839 #[allow(clippy::enum_variant_names)]
10840 enum GeneratedField {
10841 SinkId,
10842 }
10843 impl<'de> serde::Deserialize<'de> for GeneratedField {
10844 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10845 where
10846 D: serde::Deserializer<'de>,
10847 {
10848 struct GeneratedVisitor;
10849
10850 impl serde::de::Visitor<'_> for GeneratedVisitor {
10851 type Value = GeneratedField;
10852
10853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10854 write!(formatter, "expected one of: {:?}", &FIELDS)
10855 }
10856
10857 #[allow(unused_variables)]
10858 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10859 where
10860 E: serde::de::Error,
10861 {
10862 match value {
10863 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10865 }
10866 }
10867 }
10868 deserializer.deserialize_identifier(GeneratedVisitor)
10869 }
10870 }
10871 struct GeneratedVisitor;
10872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10873 type Value = ExpireIcebergTableSnapshotsRequest;
10874
10875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10876 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10877 }
10878
10879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10880 where
10881 V: serde::de::MapAccess<'de>,
10882 {
10883 let mut sink_id__ = None;
10884 while let Some(k) = map_.next_key()? {
10885 match k {
10886 GeneratedField::SinkId => {
10887 if sink_id__.is_some() {
10888 return Err(serde::de::Error::duplicate_field("sinkId"));
10889 }
10890 sink_id__ =
10891 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10892 ;
10893 }
10894 }
10895 }
10896 Ok(ExpireIcebergTableSnapshotsRequest {
10897 sink_id: sink_id__.unwrap_or_default(),
10898 })
10899 }
10900 }
10901 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10902 }
10903}
10904impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10905 #[allow(deprecated)]
10906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10907 where
10908 S: serde::Serializer,
10909 {
10910 use serde::ser::SerializeStruct;
10911 let mut len = 0;
10912 if self.status.is_some() {
10913 len += 1;
10914 }
10915 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10916 if let Some(v) = self.status.as_ref() {
10917 struct_ser.serialize_field("status", v)?;
10918 }
10919 struct_ser.end()
10920 }
10921}
10922impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10923 #[allow(deprecated)]
10924 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10925 where
10926 D: serde::Deserializer<'de>,
10927 {
10928 const FIELDS: &[&str] = &[
10929 "status",
10930 ];
10931
10932 #[allow(clippy::enum_variant_names)]
10933 enum GeneratedField {
10934 Status,
10935 }
10936 impl<'de> serde::Deserialize<'de> for GeneratedField {
10937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10938 where
10939 D: serde::Deserializer<'de>,
10940 {
10941 struct GeneratedVisitor;
10942
10943 impl serde::de::Visitor<'_> for GeneratedVisitor {
10944 type Value = GeneratedField;
10945
10946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10947 write!(formatter, "expected one of: {:?}", &FIELDS)
10948 }
10949
10950 #[allow(unused_variables)]
10951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10952 where
10953 E: serde::de::Error,
10954 {
10955 match value {
10956 "status" => Ok(GeneratedField::Status),
10957 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10958 }
10959 }
10960 }
10961 deserializer.deserialize_identifier(GeneratedVisitor)
10962 }
10963 }
10964 struct GeneratedVisitor;
10965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10966 type Value = ExpireIcebergTableSnapshotsResponse;
10967
10968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10969 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10970 }
10971
10972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10973 where
10974 V: serde::de::MapAccess<'de>,
10975 {
10976 let mut status__ = None;
10977 while let Some(k) = map_.next_key()? {
10978 match k {
10979 GeneratedField::Status => {
10980 if status__.is_some() {
10981 return Err(serde::de::Error::duplicate_field("status"));
10982 }
10983 status__ = map_.next_value()?;
10984 }
10985 }
10986 }
10987 Ok(ExpireIcebergTableSnapshotsResponse {
10988 status: status__,
10989 })
10990 }
10991 }
10992 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10993 }
10994}
10995impl serde::Serialize for GetDdlProgressRequest {
10996 #[allow(deprecated)]
10997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10998 where
10999 S: serde::Serializer,
11000 {
11001 use serde::ser::SerializeStruct;
11002 let len = 0;
11003 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
11004 struct_ser.end()
11005 }
11006}
11007impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
11008 #[allow(deprecated)]
11009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11010 where
11011 D: serde::Deserializer<'de>,
11012 {
11013 const FIELDS: &[&str] = &[
11014 ];
11015
11016 #[allow(clippy::enum_variant_names)]
11017 enum GeneratedField {
11018 }
11019 impl<'de> serde::Deserialize<'de> for GeneratedField {
11020 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11021 where
11022 D: serde::Deserializer<'de>,
11023 {
11024 struct GeneratedVisitor;
11025
11026 impl serde::de::Visitor<'_> for GeneratedVisitor {
11027 type Value = GeneratedField;
11028
11029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11030 write!(formatter, "expected one of: {:?}", &FIELDS)
11031 }
11032
11033 #[allow(unused_variables)]
11034 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11035 where
11036 E: serde::de::Error,
11037 {
11038 Err(serde::de::Error::unknown_field(value, FIELDS))
11039 }
11040 }
11041 deserializer.deserialize_identifier(GeneratedVisitor)
11042 }
11043 }
11044 struct GeneratedVisitor;
11045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11046 type Value = GetDdlProgressRequest;
11047
11048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11049 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
11050 }
11051
11052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
11053 where
11054 V: serde::de::MapAccess<'de>,
11055 {
11056 while map_.next_key::<GeneratedField>()?.is_some() {
11057 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11058 }
11059 Ok(GetDdlProgressRequest {
11060 })
11061 }
11062 }
11063 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
11064 }
11065}
11066impl serde::Serialize for GetDdlProgressResponse {
11067 #[allow(deprecated)]
11068 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11069 where
11070 S: serde::Serializer,
11071 {
11072 use serde::ser::SerializeStruct;
11073 let mut len = 0;
11074 if !self.ddl_progress.is_empty() {
11075 len += 1;
11076 }
11077 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
11078 if !self.ddl_progress.is_empty() {
11079 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
11080 }
11081 struct_ser.end()
11082 }
11083}
11084impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
11085 #[allow(deprecated)]
11086 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11087 where
11088 D: serde::Deserializer<'de>,
11089 {
11090 const FIELDS: &[&str] = &[
11091 "ddl_progress",
11092 "ddlProgress",
11093 ];
11094
11095 #[allow(clippy::enum_variant_names)]
11096 enum GeneratedField {
11097 DdlProgress,
11098 }
11099 impl<'de> serde::Deserialize<'de> for GeneratedField {
11100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11101 where
11102 D: serde::Deserializer<'de>,
11103 {
11104 struct GeneratedVisitor;
11105
11106 impl serde::de::Visitor<'_> for GeneratedVisitor {
11107 type Value = GeneratedField;
11108
11109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11110 write!(formatter, "expected one of: {:?}", &FIELDS)
11111 }
11112
11113 #[allow(unused_variables)]
11114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11115 where
11116 E: serde::de::Error,
11117 {
11118 match value {
11119 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
11120 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11121 }
11122 }
11123 }
11124 deserializer.deserialize_identifier(GeneratedVisitor)
11125 }
11126 }
11127 struct GeneratedVisitor;
11128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11129 type Value = GetDdlProgressResponse;
11130
11131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11132 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
11133 }
11134
11135 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
11136 where
11137 V: serde::de::MapAccess<'de>,
11138 {
11139 let mut ddl_progress__ = None;
11140 while let Some(k) = map_.next_key()? {
11141 match k {
11142 GeneratedField::DdlProgress => {
11143 if ddl_progress__.is_some() {
11144 return Err(serde::de::Error::duplicate_field("ddlProgress"));
11145 }
11146 ddl_progress__ = Some(map_.next_value()?);
11147 }
11148 }
11149 }
11150 Ok(GetDdlProgressResponse {
11151 ddl_progress: ddl_progress__.unwrap_or_default(),
11152 })
11153 }
11154 }
11155 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
11156 }
11157}
11158impl serde::Serialize for GetTableRequest {
11159 #[allow(deprecated)]
11160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11161 where
11162 S: serde::Serializer,
11163 {
11164 use serde::ser::SerializeStruct;
11165 let mut len = 0;
11166 if !self.database_name.is_empty() {
11167 len += 1;
11168 }
11169 if !self.table_name.is_empty() {
11170 len += 1;
11171 }
11172 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
11173 if !self.database_name.is_empty() {
11174 struct_ser.serialize_field("databaseName", &self.database_name)?;
11175 }
11176 if !self.table_name.is_empty() {
11177 struct_ser.serialize_field("tableName", &self.table_name)?;
11178 }
11179 struct_ser.end()
11180 }
11181}
11182impl<'de> serde::Deserialize<'de> for GetTableRequest {
11183 #[allow(deprecated)]
11184 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11185 where
11186 D: serde::Deserializer<'de>,
11187 {
11188 const FIELDS: &[&str] = &[
11189 "database_name",
11190 "databaseName",
11191 "table_name",
11192 "tableName",
11193 ];
11194
11195 #[allow(clippy::enum_variant_names)]
11196 enum GeneratedField {
11197 DatabaseName,
11198 TableName,
11199 }
11200 impl<'de> serde::Deserialize<'de> for GeneratedField {
11201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11202 where
11203 D: serde::Deserializer<'de>,
11204 {
11205 struct GeneratedVisitor;
11206
11207 impl serde::de::Visitor<'_> for GeneratedVisitor {
11208 type Value = GeneratedField;
11209
11210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11211 write!(formatter, "expected one of: {:?}", &FIELDS)
11212 }
11213
11214 #[allow(unused_variables)]
11215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11216 where
11217 E: serde::de::Error,
11218 {
11219 match value {
11220 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
11221 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11223 }
11224 }
11225 }
11226 deserializer.deserialize_identifier(GeneratedVisitor)
11227 }
11228 }
11229 struct GeneratedVisitor;
11230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11231 type Value = GetTableRequest;
11232
11233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11234 formatter.write_str("struct ddl_service.GetTableRequest")
11235 }
11236
11237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
11238 where
11239 V: serde::de::MapAccess<'de>,
11240 {
11241 let mut database_name__ = None;
11242 let mut table_name__ = None;
11243 while let Some(k) = map_.next_key()? {
11244 match k {
11245 GeneratedField::DatabaseName => {
11246 if database_name__.is_some() {
11247 return Err(serde::de::Error::duplicate_field("databaseName"));
11248 }
11249 database_name__ = Some(map_.next_value()?);
11250 }
11251 GeneratedField::TableName => {
11252 if table_name__.is_some() {
11253 return Err(serde::de::Error::duplicate_field("tableName"));
11254 }
11255 table_name__ = Some(map_.next_value()?);
11256 }
11257 }
11258 }
11259 Ok(GetTableRequest {
11260 database_name: database_name__.unwrap_or_default(),
11261 table_name: table_name__.unwrap_or_default(),
11262 })
11263 }
11264 }
11265 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
11266 }
11267}
11268impl serde::Serialize for GetTableResponse {
11269 #[allow(deprecated)]
11270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11271 where
11272 S: serde::Serializer,
11273 {
11274 use serde::ser::SerializeStruct;
11275 let mut len = 0;
11276 if self.table.is_some() {
11277 len += 1;
11278 }
11279 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
11280 if let Some(v) = self.table.as_ref() {
11281 struct_ser.serialize_field("table", v)?;
11282 }
11283 struct_ser.end()
11284 }
11285}
11286impl<'de> serde::Deserialize<'de> for GetTableResponse {
11287 #[allow(deprecated)]
11288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11289 where
11290 D: serde::Deserializer<'de>,
11291 {
11292 const FIELDS: &[&str] = &[
11293 "table",
11294 ];
11295
11296 #[allow(clippy::enum_variant_names)]
11297 enum GeneratedField {
11298 Table,
11299 }
11300 impl<'de> serde::Deserialize<'de> for GeneratedField {
11301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11302 where
11303 D: serde::Deserializer<'de>,
11304 {
11305 struct GeneratedVisitor;
11306
11307 impl serde::de::Visitor<'_> for GeneratedVisitor {
11308 type Value = GeneratedField;
11309
11310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11311 write!(formatter, "expected one of: {:?}", &FIELDS)
11312 }
11313
11314 #[allow(unused_variables)]
11315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11316 where
11317 E: serde::de::Error,
11318 {
11319 match value {
11320 "table" => Ok(GeneratedField::Table),
11321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11322 }
11323 }
11324 }
11325 deserializer.deserialize_identifier(GeneratedVisitor)
11326 }
11327 }
11328 struct GeneratedVisitor;
11329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11330 type Value = GetTableResponse;
11331
11332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11333 formatter.write_str("struct ddl_service.GetTableResponse")
11334 }
11335
11336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
11337 where
11338 V: serde::de::MapAccess<'de>,
11339 {
11340 let mut table__ = None;
11341 while let Some(k) = map_.next_key()? {
11342 match k {
11343 GeneratedField::Table => {
11344 if table__.is_some() {
11345 return Err(serde::de::Error::duplicate_field("table"));
11346 }
11347 table__ = map_.next_value()?;
11348 }
11349 }
11350 }
11351 Ok(GetTableResponse {
11352 table: table__,
11353 })
11354 }
11355 }
11356 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
11357 }
11358}
11359impl serde::Serialize for GetTablesRequest {
11360 #[allow(deprecated)]
11361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11362 where
11363 S: serde::Serializer,
11364 {
11365 use serde::ser::SerializeStruct;
11366 let mut len = 0;
11367 if !self.table_ids.is_empty() {
11368 len += 1;
11369 }
11370 if self.include_dropped_tables {
11371 len += 1;
11372 }
11373 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
11374 if !self.table_ids.is_empty() {
11375 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11376 }
11377 if self.include_dropped_tables {
11378 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
11379 }
11380 struct_ser.end()
11381 }
11382}
11383impl<'de> serde::Deserialize<'de> for GetTablesRequest {
11384 #[allow(deprecated)]
11385 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11386 where
11387 D: serde::Deserializer<'de>,
11388 {
11389 const FIELDS: &[&str] = &[
11390 "table_ids",
11391 "tableIds",
11392 "include_dropped_tables",
11393 "includeDroppedTables",
11394 ];
11395
11396 #[allow(clippy::enum_variant_names)]
11397 enum GeneratedField {
11398 TableIds,
11399 IncludeDroppedTables,
11400 }
11401 impl<'de> serde::Deserialize<'de> for GeneratedField {
11402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11403 where
11404 D: serde::Deserializer<'de>,
11405 {
11406 struct GeneratedVisitor;
11407
11408 impl serde::de::Visitor<'_> for GeneratedVisitor {
11409 type Value = GeneratedField;
11410
11411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11412 write!(formatter, "expected one of: {:?}", &FIELDS)
11413 }
11414
11415 #[allow(unused_variables)]
11416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11417 where
11418 E: serde::de::Error,
11419 {
11420 match value {
11421 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11422 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
11423 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11424 }
11425 }
11426 }
11427 deserializer.deserialize_identifier(GeneratedVisitor)
11428 }
11429 }
11430 struct GeneratedVisitor;
11431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11432 type Value = GetTablesRequest;
11433
11434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11435 formatter.write_str("struct ddl_service.GetTablesRequest")
11436 }
11437
11438 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
11439 where
11440 V: serde::de::MapAccess<'de>,
11441 {
11442 let mut table_ids__ = None;
11443 let mut include_dropped_tables__ = None;
11444 while let Some(k) = map_.next_key()? {
11445 match k {
11446 GeneratedField::TableIds => {
11447 if table_ids__.is_some() {
11448 return Err(serde::de::Error::duplicate_field("tableIds"));
11449 }
11450 table_ids__ =
11451 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11452 .into_iter().map(|x| x.0).collect())
11453 ;
11454 }
11455 GeneratedField::IncludeDroppedTables => {
11456 if include_dropped_tables__.is_some() {
11457 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
11458 }
11459 include_dropped_tables__ = Some(map_.next_value()?);
11460 }
11461 }
11462 }
11463 Ok(GetTablesRequest {
11464 table_ids: table_ids__.unwrap_or_default(),
11465 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
11466 })
11467 }
11468 }
11469 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
11470 }
11471}
11472impl serde::Serialize for GetTablesResponse {
11473 #[allow(deprecated)]
11474 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11475 where
11476 S: serde::Serializer,
11477 {
11478 use serde::ser::SerializeStruct;
11479 let mut len = 0;
11480 if !self.tables.is_empty() {
11481 len += 1;
11482 }
11483 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
11484 if !self.tables.is_empty() {
11485 struct_ser.serialize_field("tables", &self.tables)?;
11486 }
11487 struct_ser.end()
11488 }
11489}
11490impl<'de> serde::Deserialize<'de> for GetTablesResponse {
11491 #[allow(deprecated)]
11492 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11493 where
11494 D: serde::Deserializer<'de>,
11495 {
11496 const FIELDS: &[&str] = &[
11497 "tables",
11498 ];
11499
11500 #[allow(clippy::enum_variant_names)]
11501 enum GeneratedField {
11502 Tables,
11503 }
11504 impl<'de> serde::Deserialize<'de> for GeneratedField {
11505 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11506 where
11507 D: serde::Deserializer<'de>,
11508 {
11509 struct GeneratedVisitor;
11510
11511 impl serde::de::Visitor<'_> for GeneratedVisitor {
11512 type Value = GeneratedField;
11513
11514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11515 write!(formatter, "expected one of: {:?}", &FIELDS)
11516 }
11517
11518 #[allow(unused_variables)]
11519 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11520 where
11521 E: serde::de::Error,
11522 {
11523 match value {
11524 "tables" => Ok(GeneratedField::Tables),
11525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11526 }
11527 }
11528 }
11529 deserializer.deserialize_identifier(GeneratedVisitor)
11530 }
11531 }
11532 struct GeneratedVisitor;
11533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11534 type Value = GetTablesResponse;
11535
11536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11537 formatter.write_str("struct ddl_service.GetTablesResponse")
11538 }
11539
11540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
11541 where
11542 V: serde::de::MapAccess<'de>,
11543 {
11544 let mut tables__ = None;
11545 while let Some(k) = map_.next_key()? {
11546 match k {
11547 GeneratedField::Tables => {
11548 if tables__.is_some() {
11549 return Err(serde::de::Error::duplicate_field("tables"));
11550 }
11551 tables__ = Some(
11552 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11553 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11554 );
11555 }
11556 }
11557 }
11558 Ok(GetTablesResponse {
11559 tables: tables__.unwrap_or_default(),
11560 })
11561 }
11562 }
11563 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
11564 }
11565}
11566impl serde::Serialize for ListConnectionsRequest {
11567 #[allow(deprecated)]
11568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11569 where
11570 S: serde::Serializer,
11571 {
11572 use serde::ser::SerializeStruct;
11573 let len = 0;
11574 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
11575 struct_ser.end()
11576 }
11577}
11578impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
11579 #[allow(deprecated)]
11580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11581 where
11582 D: serde::Deserializer<'de>,
11583 {
11584 const FIELDS: &[&str] = &[
11585 ];
11586
11587 #[allow(clippy::enum_variant_names)]
11588 enum GeneratedField {
11589 }
11590 impl<'de> serde::Deserialize<'de> for GeneratedField {
11591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11592 where
11593 D: serde::Deserializer<'de>,
11594 {
11595 struct GeneratedVisitor;
11596
11597 impl serde::de::Visitor<'_> for GeneratedVisitor {
11598 type Value = GeneratedField;
11599
11600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11601 write!(formatter, "expected one of: {:?}", &FIELDS)
11602 }
11603
11604 #[allow(unused_variables)]
11605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11606 where
11607 E: serde::de::Error,
11608 {
11609 Err(serde::de::Error::unknown_field(value, FIELDS))
11610 }
11611 }
11612 deserializer.deserialize_identifier(GeneratedVisitor)
11613 }
11614 }
11615 struct GeneratedVisitor;
11616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11617 type Value = ListConnectionsRequest;
11618
11619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11620 formatter.write_str("struct ddl_service.ListConnectionsRequest")
11621 }
11622
11623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
11624 where
11625 V: serde::de::MapAccess<'de>,
11626 {
11627 while map_.next_key::<GeneratedField>()?.is_some() {
11628 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11629 }
11630 Ok(ListConnectionsRequest {
11631 })
11632 }
11633 }
11634 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
11635 }
11636}
11637impl serde::Serialize for ListConnectionsResponse {
11638 #[allow(deprecated)]
11639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11640 where
11641 S: serde::Serializer,
11642 {
11643 use serde::ser::SerializeStruct;
11644 let mut len = 0;
11645 if !self.connections.is_empty() {
11646 len += 1;
11647 }
11648 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
11649 if !self.connections.is_empty() {
11650 struct_ser.serialize_field("connections", &self.connections)?;
11651 }
11652 struct_ser.end()
11653 }
11654}
11655impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
11656 #[allow(deprecated)]
11657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11658 where
11659 D: serde::Deserializer<'de>,
11660 {
11661 const FIELDS: &[&str] = &[
11662 "connections",
11663 ];
11664
11665 #[allow(clippy::enum_variant_names)]
11666 enum GeneratedField {
11667 Connections,
11668 }
11669 impl<'de> serde::Deserialize<'de> for GeneratedField {
11670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11671 where
11672 D: serde::Deserializer<'de>,
11673 {
11674 struct GeneratedVisitor;
11675
11676 impl serde::de::Visitor<'_> for GeneratedVisitor {
11677 type Value = GeneratedField;
11678
11679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11680 write!(formatter, "expected one of: {:?}", &FIELDS)
11681 }
11682
11683 #[allow(unused_variables)]
11684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11685 where
11686 E: serde::de::Error,
11687 {
11688 match value {
11689 "connections" => Ok(GeneratedField::Connections),
11690 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11691 }
11692 }
11693 }
11694 deserializer.deserialize_identifier(GeneratedVisitor)
11695 }
11696 }
11697 struct GeneratedVisitor;
11698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11699 type Value = ListConnectionsResponse;
11700
11701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11702 formatter.write_str("struct ddl_service.ListConnectionsResponse")
11703 }
11704
11705 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
11706 where
11707 V: serde::de::MapAccess<'de>,
11708 {
11709 let mut connections__ = None;
11710 while let Some(k) = map_.next_key()? {
11711 match k {
11712 GeneratedField::Connections => {
11713 if connections__.is_some() {
11714 return Err(serde::de::Error::duplicate_field("connections"));
11715 }
11716 connections__ = Some(map_.next_value()?);
11717 }
11718 }
11719 }
11720 Ok(ListConnectionsResponse {
11721 connections: connections__.unwrap_or_default(),
11722 })
11723 }
11724 }
11725 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
11726 }
11727}
11728impl serde::Serialize for ReplaceJobPlan {
11729 #[allow(deprecated)]
11730 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11731 where
11732 S: serde::Serializer,
11733 {
11734 use serde::ser::SerializeStruct;
11735 let mut len = 0;
11736 if self.fragment_graph.is_some() {
11737 len += 1;
11738 }
11739 if self.replace_job.is_some() {
11740 len += 1;
11741 }
11742 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
11743 if let Some(v) = self.fragment_graph.as_ref() {
11744 struct_ser.serialize_field("fragmentGraph", v)?;
11745 }
11746 if let Some(v) = self.replace_job.as_ref() {
11747 match v {
11748 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
11749 struct_ser.serialize_field("replaceTable", v)?;
11750 }
11751 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
11752 struct_ser.serialize_field("replaceSource", v)?;
11753 }
11754 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
11755 struct_ser.serialize_field("replaceMaterializedView", v)?;
11756 }
11757 replace_job_plan::ReplaceJob::ReplaceSink(v) => {
11758 struct_ser.serialize_field("replaceSink", v)?;
11759 }
11760 }
11761 }
11762 struct_ser.end()
11763 }
11764}
11765impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
11766 #[allow(deprecated)]
11767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11768 where
11769 D: serde::Deserializer<'de>,
11770 {
11771 const FIELDS: &[&str] = &[
11772 "fragment_graph",
11773 "fragmentGraph",
11774 "replace_table",
11775 "replaceTable",
11776 "replace_source",
11777 "replaceSource",
11778 "replace_materialized_view",
11779 "replaceMaterializedView",
11780 "replace_sink",
11781 "replaceSink",
11782 ];
11783
11784 #[allow(clippy::enum_variant_names)]
11785 enum GeneratedField {
11786 FragmentGraph,
11787 ReplaceTable,
11788 ReplaceSource,
11789 ReplaceMaterializedView,
11790 ReplaceSink,
11791 }
11792 impl<'de> serde::Deserialize<'de> for GeneratedField {
11793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11794 where
11795 D: serde::Deserializer<'de>,
11796 {
11797 struct GeneratedVisitor;
11798
11799 impl serde::de::Visitor<'_> for GeneratedVisitor {
11800 type Value = GeneratedField;
11801
11802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11803 write!(formatter, "expected one of: {:?}", &FIELDS)
11804 }
11805
11806 #[allow(unused_variables)]
11807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11808 where
11809 E: serde::de::Error,
11810 {
11811 match value {
11812 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
11813 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
11814 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
11815 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
11816 "replaceSink" | "replace_sink" => Ok(GeneratedField::ReplaceSink),
11817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11818 }
11819 }
11820 }
11821 deserializer.deserialize_identifier(GeneratedVisitor)
11822 }
11823 }
11824 struct GeneratedVisitor;
11825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11826 type Value = ReplaceJobPlan;
11827
11828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11829 formatter.write_str("struct ddl_service.ReplaceJobPlan")
11830 }
11831
11832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
11833 where
11834 V: serde::de::MapAccess<'de>,
11835 {
11836 let mut fragment_graph__ = None;
11837 let mut replace_job__ = None;
11838 while let Some(k) = map_.next_key()? {
11839 match k {
11840 GeneratedField::FragmentGraph => {
11841 if fragment_graph__.is_some() {
11842 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11843 }
11844 fragment_graph__ = map_.next_value()?;
11845 }
11846 GeneratedField::ReplaceTable => {
11847 if replace_job__.is_some() {
11848 return Err(serde::de::Error::duplicate_field("replaceTable"));
11849 }
11850 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11851;
11852 }
11853 GeneratedField::ReplaceSource => {
11854 if replace_job__.is_some() {
11855 return Err(serde::de::Error::duplicate_field("replaceSource"));
11856 }
11857 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11858;
11859 }
11860 GeneratedField::ReplaceMaterializedView => {
11861 if replace_job__.is_some() {
11862 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11863 }
11864 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11865;
11866 }
11867 GeneratedField::ReplaceSink => {
11868 if replace_job__.is_some() {
11869 return Err(serde::de::Error::duplicate_field("replaceSink"));
11870 }
11871 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSink)
11872;
11873 }
11874 }
11875 }
11876 Ok(ReplaceJobPlan {
11877 fragment_graph: fragment_graph__,
11878 replace_job: replace_job__,
11879 })
11880 }
11881 }
11882 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11883 }
11884}
11885impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
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.table.is_some() {
11894 len += 1;
11895 }
11896 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11897 if let Some(v) = self.table.as_ref() {
11898 struct_ser.serialize_field("table", v)?;
11899 }
11900 struct_ser.end()
11901 }
11902}
11903impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
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 "table",
11911 ];
11912
11913 #[allow(clippy::enum_variant_names)]
11914 enum GeneratedField {
11915 Table,
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 "table" => Ok(GeneratedField::Table),
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 = replace_job_plan::ReplaceMaterializedView;
11948
11949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11950 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11951 }
11952
11953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11954 where
11955 V: serde::de::MapAccess<'de>,
11956 {
11957 let mut table__ = None;
11958 while let Some(k) = map_.next_key()? {
11959 match k {
11960 GeneratedField::Table => {
11961 if table__.is_some() {
11962 return Err(serde::de::Error::duplicate_field("table"));
11963 }
11964 table__ = map_.next_value()?;
11965 }
11966 }
11967 }
11968 Ok(replace_job_plan::ReplaceMaterializedView {
11969 table: table__,
11970 })
11971 }
11972 }
11973 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11974 }
11975}
11976impl serde::Serialize for replace_job_plan::ReplaceSink {
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.sink.is_some() {
11985 len += 1;
11986 }
11987 if self.old_sink_id != 0 {
11988 len += 1;
11989 }
11990 if !self.dependencies.is_empty() {
11991 len += 1;
11992 }
11993 if self.resource_type.is_some() {
11994 len += 1;
11995 }
11996 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSink", len)?;
11997 if let Some(v) = self.sink.as_ref() {
11998 struct_ser.serialize_field("sink", v)?;
11999 }
12000 if self.old_sink_id != 0 {
12001 struct_ser.serialize_field("oldSinkId", &self.old_sink_id)?;
12002 }
12003 if !self.dependencies.is_empty() {
12004 struct_ser.serialize_field("dependencies", &self.dependencies)?;
12005 }
12006 if let Some(v) = self.resource_type.as_ref() {
12007 struct_ser.serialize_field("resourceType", v)?;
12008 }
12009 struct_ser.end()
12010 }
12011}
12012impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSink {
12013 #[allow(deprecated)]
12014 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12015 where
12016 D: serde::Deserializer<'de>,
12017 {
12018 const FIELDS: &[&str] = &[
12019 "sink",
12020 "old_sink_id",
12021 "oldSinkId",
12022 "dependencies",
12023 "resource_type",
12024 "resourceType",
12025 ];
12026
12027 #[allow(clippy::enum_variant_names)]
12028 enum GeneratedField {
12029 Sink,
12030 OldSinkId,
12031 Dependencies,
12032 ResourceType,
12033 }
12034 impl<'de> serde::Deserialize<'de> for GeneratedField {
12035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12036 where
12037 D: serde::Deserializer<'de>,
12038 {
12039 struct GeneratedVisitor;
12040
12041 impl serde::de::Visitor<'_> for GeneratedVisitor {
12042 type Value = GeneratedField;
12043
12044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12045 write!(formatter, "expected one of: {:?}", &FIELDS)
12046 }
12047
12048 #[allow(unused_variables)]
12049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12050 where
12051 E: serde::de::Error,
12052 {
12053 match value {
12054 "sink" => Ok(GeneratedField::Sink),
12055 "oldSinkId" | "old_sink_id" => Ok(GeneratedField::OldSinkId),
12056 "dependencies" => Ok(GeneratedField::Dependencies),
12057 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
12058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12059 }
12060 }
12061 }
12062 deserializer.deserialize_identifier(GeneratedVisitor)
12063 }
12064 }
12065 struct GeneratedVisitor;
12066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12067 type Value = replace_job_plan::ReplaceSink;
12068
12069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12070 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSink")
12071 }
12072
12073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSink, V::Error>
12074 where
12075 V: serde::de::MapAccess<'de>,
12076 {
12077 let mut sink__ = None;
12078 let mut old_sink_id__ = None;
12079 let mut dependencies__ = None;
12080 let mut resource_type__ = None;
12081 while let Some(k) = map_.next_key()? {
12082 match k {
12083 GeneratedField::Sink => {
12084 if sink__.is_some() {
12085 return Err(serde::de::Error::duplicate_field("sink"));
12086 }
12087 sink__ = map_.next_value()?;
12088 }
12089 GeneratedField::OldSinkId => {
12090 if old_sink_id__.is_some() {
12091 return Err(serde::de::Error::duplicate_field("oldSinkId"));
12092 }
12093 old_sink_id__ =
12094 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12095 ;
12096 }
12097 GeneratedField::Dependencies => {
12098 if dependencies__.is_some() {
12099 return Err(serde::de::Error::duplicate_field("dependencies"));
12100 }
12101 dependencies__ =
12102 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12103 .into_iter().map(|x| x.0).collect())
12104 ;
12105 }
12106 GeneratedField::ResourceType => {
12107 if resource_type__.is_some() {
12108 return Err(serde::de::Error::duplicate_field("resourceType"));
12109 }
12110 resource_type__ = map_.next_value()?;
12111 }
12112 }
12113 }
12114 Ok(replace_job_plan::ReplaceSink {
12115 sink: sink__,
12116 old_sink_id: old_sink_id__.unwrap_or_default(),
12117 dependencies: dependencies__.unwrap_or_default(),
12118 resource_type: resource_type__,
12119 })
12120 }
12121 }
12122 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSink", FIELDS, GeneratedVisitor)
12123 }
12124}
12125impl serde::Serialize for replace_job_plan::ReplaceSource {
12126 #[allow(deprecated)]
12127 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12128 where
12129 S: serde::Serializer,
12130 {
12131 use serde::ser::SerializeStruct;
12132 let mut len = 0;
12133 if self.source.is_some() {
12134 len += 1;
12135 }
12136 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
12137 if let Some(v) = self.source.as_ref() {
12138 struct_ser.serialize_field("source", v)?;
12139 }
12140 struct_ser.end()
12141 }
12142}
12143impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
12144 #[allow(deprecated)]
12145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12146 where
12147 D: serde::Deserializer<'de>,
12148 {
12149 const FIELDS: &[&str] = &[
12150 "source",
12151 ];
12152
12153 #[allow(clippy::enum_variant_names)]
12154 enum GeneratedField {
12155 Source,
12156 }
12157 impl<'de> serde::Deserialize<'de> for GeneratedField {
12158 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12159 where
12160 D: serde::Deserializer<'de>,
12161 {
12162 struct GeneratedVisitor;
12163
12164 impl serde::de::Visitor<'_> for GeneratedVisitor {
12165 type Value = GeneratedField;
12166
12167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12168 write!(formatter, "expected one of: {:?}", &FIELDS)
12169 }
12170
12171 #[allow(unused_variables)]
12172 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12173 where
12174 E: serde::de::Error,
12175 {
12176 match value {
12177 "source" => Ok(GeneratedField::Source),
12178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12179 }
12180 }
12181 }
12182 deserializer.deserialize_identifier(GeneratedVisitor)
12183 }
12184 }
12185 struct GeneratedVisitor;
12186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12187 type Value = replace_job_plan::ReplaceSource;
12188
12189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12190 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
12191 }
12192
12193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
12194 where
12195 V: serde::de::MapAccess<'de>,
12196 {
12197 let mut source__ = None;
12198 while let Some(k) = map_.next_key()? {
12199 match k {
12200 GeneratedField::Source => {
12201 if source__.is_some() {
12202 return Err(serde::de::Error::duplicate_field("source"));
12203 }
12204 source__ = map_.next_value()?;
12205 }
12206 }
12207 }
12208 Ok(replace_job_plan::ReplaceSource {
12209 source: source__,
12210 })
12211 }
12212 }
12213 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
12214 }
12215}
12216impl serde::Serialize for replace_job_plan::ReplaceTable {
12217 #[allow(deprecated)]
12218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12219 where
12220 S: serde::Serializer,
12221 {
12222 use serde::ser::SerializeStruct;
12223 let mut len = 0;
12224 if self.table.is_some() {
12225 len += 1;
12226 }
12227 if self.source.is_some() {
12228 len += 1;
12229 }
12230 if self.job_type != 0 {
12231 len += 1;
12232 }
12233 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
12234 if let Some(v) = self.table.as_ref() {
12235 struct_ser.serialize_field("table", v)?;
12236 }
12237 if let Some(v) = self.source.as_ref() {
12238 struct_ser.serialize_field("source", v)?;
12239 }
12240 if self.job_type != 0 {
12241 let v = TableJobType::try_from(self.job_type)
12242 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
12243 struct_ser.serialize_field("jobType", &v)?;
12244 }
12245 struct_ser.end()
12246 }
12247}
12248impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
12249 #[allow(deprecated)]
12250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12251 where
12252 D: serde::Deserializer<'de>,
12253 {
12254 const FIELDS: &[&str] = &[
12255 "table",
12256 "source",
12257 "job_type",
12258 "jobType",
12259 ];
12260
12261 #[allow(clippy::enum_variant_names)]
12262 enum GeneratedField {
12263 Table,
12264 Source,
12265 JobType,
12266 }
12267 impl<'de> serde::Deserialize<'de> for GeneratedField {
12268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12269 where
12270 D: serde::Deserializer<'de>,
12271 {
12272 struct GeneratedVisitor;
12273
12274 impl serde::de::Visitor<'_> for GeneratedVisitor {
12275 type Value = GeneratedField;
12276
12277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12278 write!(formatter, "expected one of: {:?}", &FIELDS)
12279 }
12280
12281 #[allow(unused_variables)]
12282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12283 where
12284 E: serde::de::Error,
12285 {
12286 match value {
12287 "table" => Ok(GeneratedField::Table),
12288 "source" => Ok(GeneratedField::Source),
12289 "jobType" | "job_type" => Ok(GeneratedField::JobType),
12290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12291 }
12292 }
12293 }
12294 deserializer.deserialize_identifier(GeneratedVisitor)
12295 }
12296 }
12297 struct GeneratedVisitor;
12298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12299 type Value = replace_job_plan::ReplaceTable;
12300
12301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12302 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
12303 }
12304
12305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
12306 where
12307 V: serde::de::MapAccess<'de>,
12308 {
12309 let mut table__ = None;
12310 let mut source__ = None;
12311 let mut job_type__ = None;
12312 while let Some(k) = map_.next_key()? {
12313 match k {
12314 GeneratedField::Table => {
12315 if table__.is_some() {
12316 return Err(serde::de::Error::duplicate_field("table"));
12317 }
12318 table__ = map_.next_value()?;
12319 }
12320 GeneratedField::Source => {
12321 if source__.is_some() {
12322 return Err(serde::de::Error::duplicate_field("source"));
12323 }
12324 source__ = map_.next_value()?;
12325 }
12326 GeneratedField::JobType => {
12327 if job_type__.is_some() {
12328 return Err(serde::de::Error::duplicate_field("jobType"));
12329 }
12330 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
12331 }
12332 }
12333 }
12334 Ok(replace_job_plan::ReplaceTable {
12335 table: table__,
12336 source: source__,
12337 job_type: job_type__.unwrap_or_default(),
12338 })
12339 }
12340 }
12341 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
12342 }
12343}
12344impl serde::Serialize for ReplaceJobPlanRequest {
12345 #[allow(deprecated)]
12346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12347 where
12348 S: serde::Serializer,
12349 {
12350 use serde::ser::SerializeStruct;
12351 let mut len = 0;
12352 if self.plan.is_some() {
12353 len += 1;
12354 }
12355 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
12356 if let Some(v) = self.plan.as_ref() {
12357 struct_ser.serialize_field("plan", v)?;
12358 }
12359 struct_ser.end()
12360 }
12361}
12362impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
12363 #[allow(deprecated)]
12364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12365 where
12366 D: serde::Deserializer<'de>,
12367 {
12368 const FIELDS: &[&str] = &[
12369 "plan",
12370 ];
12371
12372 #[allow(clippy::enum_variant_names)]
12373 enum GeneratedField {
12374 Plan,
12375 }
12376 impl<'de> serde::Deserialize<'de> for GeneratedField {
12377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12378 where
12379 D: serde::Deserializer<'de>,
12380 {
12381 struct GeneratedVisitor;
12382
12383 impl serde::de::Visitor<'_> for GeneratedVisitor {
12384 type Value = GeneratedField;
12385
12386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12387 write!(formatter, "expected one of: {:?}", &FIELDS)
12388 }
12389
12390 #[allow(unused_variables)]
12391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12392 where
12393 E: serde::de::Error,
12394 {
12395 match value {
12396 "plan" => Ok(GeneratedField::Plan),
12397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12398 }
12399 }
12400 }
12401 deserializer.deserialize_identifier(GeneratedVisitor)
12402 }
12403 }
12404 struct GeneratedVisitor;
12405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12406 type Value = ReplaceJobPlanRequest;
12407
12408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12409 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
12410 }
12411
12412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
12413 where
12414 V: serde::de::MapAccess<'de>,
12415 {
12416 let mut plan__ = None;
12417 while let Some(k) = map_.next_key()? {
12418 match k {
12419 GeneratedField::Plan => {
12420 if plan__.is_some() {
12421 return Err(serde::de::Error::duplicate_field("plan"));
12422 }
12423 plan__ = map_.next_value()?;
12424 }
12425 }
12426 }
12427 Ok(ReplaceJobPlanRequest {
12428 plan: plan__,
12429 })
12430 }
12431 }
12432 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
12433 }
12434}
12435impl serde::Serialize for ReplaceJobPlanResponse {
12436 #[allow(deprecated)]
12437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12438 where
12439 S: serde::Serializer,
12440 {
12441 use serde::ser::SerializeStruct;
12442 let mut len = 0;
12443 if self.status.is_some() {
12444 len += 1;
12445 }
12446 if self.version.is_some() {
12447 len += 1;
12448 }
12449 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
12450 if let Some(v) = self.status.as_ref() {
12451 struct_ser.serialize_field("status", v)?;
12452 }
12453 if let Some(v) = self.version.as_ref() {
12454 struct_ser.serialize_field("version", v)?;
12455 }
12456 struct_ser.end()
12457 }
12458}
12459impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
12460 #[allow(deprecated)]
12461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12462 where
12463 D: serde::Deserializer<'de>,
12464 {
12465 const FIELDS: &[&str] = &[
12466 "status",
12467 "version",
12468 ];
12469
12470 #[allow(clippy::enum_variant_names)]
12471 enum GeneratedField {
12472 Status,
12473 Version,
12474 }
12475 impl<'de> serde::Deserialize<'de> for GeneratedField {
12476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12477 where
12478 D: serde::Deserializer<'de>,
12479 {
12480 struct GeneratedVisitor;
12481
12482 impl serde::de::Visitor<'_> for GeneratedVisitor {
12483 type Value = GeneratedField;
12484
12485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12486 write!(formatter, "expected one of: {:?}", &FIELDS)
12487 }
12488
12489 #[allow(unused_variables)]
12490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12491 where
12492 E: serde::de::Error,
12493 {
12494 match value {
12495 "status" => Ok(GeneratedField::Status),
12496 "version" => Ok(GeneratedField::Version),
12497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12498 }
12499 }
12500 }
12501 deserializer.deserialize_identifier(GeneratedVisitor)
12502 }
12503 }
12504 struct GeneratedVisitor;
12505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12506 type Value = ReplaceJobPlanResponse;
12507
12508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12509 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
12510 }
12511
12512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
12513 where
12514 V: serde::de::MapAccess<'de>,
12515 {
12516 let mut status__ = None;
12517 let mut version__ = None;
12518 while let Some(k) = map_.next_key()? {
12519 match k {
12520 GeneratedField::Status => {
12521 if status__.is_some() {
12522 return Err(serde::de::Error::duplicate_field("status"));
12523 }
12524 status__ = map_.next_value()?;
12525 }
12526 GeneratedField::Version => {
12527 if version__.is_some() {
12528 return Err(serde::de::Error::duplicate_field("version"));
12529 }
12530 version__ = map_.next_value()?;
12531 }
12532 }
12533 }
12534 Ok(ReplaceJobPlanResponse {
12535 status: status__,
12536 version: version__,
12537 })
12538 }
12539 }
12540 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
12541 }
12542}
12543impl serde::Serialize for ResetSourceRequest {
12544 #[allow(deprecated)]
12545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12546 where
12547 S: serde::Serializer,
12548 {
12549 use serde::ser::SerializeStruct;
12550 let mut len = 0;
12551 if self.source_id != 0 {
12552 len += 1;
12553 }
12554 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
12555 if self.source_id != 0 {
12556 struct_ser.serialize_field("sourceId", &self.source_id)?;
12557 }
12558 struct_ser.end()
12559 }
12560}
12561impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
12562 #[allow(deprecated)]
12563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12564 where
12565 D: serde::Deserializer<'de>,
12566 {
12567 const FIELDS: &[&str] = &[
12568 "source_id",
12569 "sourceId",
12570 ];
12571
12572 #[allow(clippy::enum_variant_names)]
12573 enum GeneratedField {
12574 SourceId,
12575 }
12576 impl<'de> serde::Deserialize<'de> for GeneratedField {
12577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12578 where
12579 D: serde::Deserializer<'de>,
12580 {
12581 struct GeneratedVisitor;
12582
12583 impl serde::de::Visitor<'_> for GeneratedVisitor {
12584 type Value = GeneratedField;
12585
12586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12587 write!(formatter, "expected one of: {:?}", &FIELDS)
12588 }
12589
12590 #[allow(unused_variables)]
12591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12592 where
12593 E: serde::de::Error,
12594 {
12595 match value {
12596 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12598 }
12599 }
12600 }
12601 deserializer.deserialize_identifier(GeneratedVisitor)
12602 }
12603 }
12604 struct GeneratedVisitor;
12605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12606 type Value = ResetSourceRequest;
12607
12608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12609 formatter.write_str("struct ddl_service.ResetSourceRequest")
12610 }
12611
12612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
12613 where
12614 V: serde::de::MapAccess<'de>,
12615 {
12616 let mut source_id__ = None;
12617 while let Some(k) = map_.next_key()? {
12618 match k {
12619 GeneratedField::SourceId => {
12620 if source_id__.is_some() {
12621 return Err(serde::de::Error::duplicate_field("sourceId"));
12622 }
12623 source_id__ =
12624 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12625 ;
12626 }
12627 }
12628 }
12629 Ok(ResetSourceRequest {
12630 source_id: source_id__.unwrap_or_default(),
12631 })
12632 }
12633 }
12634 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
12635 }
12636}
12637impl serde::Serialize for ResetSourceResponse {
12638 #[allow(deprecated)]
12639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12640 where
12641 S: serde::Serializer,
12642 {
12643 use serde::ser::SerializeStruct;
12644 let mut len = 0;
12645 if self.status.is_some() {
12646 len += 1;
12647 }
12648 if self.version.is_some() {
12649 len += 1;
12650 }
12651 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
12652 if let Some(v) = self.status.as_ref() {
12653 struct_ser.serialize_field("status", v)?;
12654 }
12655 if let Some(v) = self.version.as_ref() {
12656 struct_ser.serialize_field("version", v)?;
12657 }
12658 struct_ser.end()
12659 }
12660}
12661impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
12662 #[allow(deprecated)]
12663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12664 where
12665 D: serde::Deserializer<'de>,
12666 {
12667 const FIELDS: &[&str] = &[
12668 "status",
12669 "version",
12670 ];
12671
12672 #[allow(clippy::enum_variant_names)]
12673 enum GeneratedField {
12674 Status,
12675 Version,
12676 }
12677 impl<'de> serde::Deserialize<'de> for GeneratedField {
12678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12679 where
12680 D: serde::Deserializer<'de>,
12681 {
12682 struct GeneratedVisitor;
12683
12684 impl serde::de::Visitor<'_> for GeneratedVisitor {
12685 type Value = GeneratedField;
12686
12687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12688 write!(formatter, "expected one of: {:?}", &FIELDS)
12689 }
12690
12691 #[allow(unused_variables)]
12692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12693 where
12694 E: serde::de::Error,
12695 {
12696 match value {
12697 "status" => Ok(GeneratedField::Status),
12698 "version" => Ok(GeneratedField::Version),
12699 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12700 }
12701 }
12702 }
12703 deserializer.deserialize_identifier(GeneratedVisitor)
12704 }
12705 }
12706 struct GeneratedVisitor;
12707 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12708 type Value = ResetSourceResponse;
12709
12710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12711 formatter.write_str("struct ddl_service.ResetSourceResponse")
12712 }
12713
12714 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
12715 where
12716 V: serde::de::MapAccess<'de>,
12717 {
12718 let mut status__ = None;
12719 let mut version__ = None;
12720 while let Some(k) = map_.next_key()? {
12721 match k {
12722 GeneratedField::Status => {
12723 if status__.is_some() {
12724 return Err(serde::de::Error::duplicate_field("status"));
12725 }
12726 status__ = map_.next_value()?;
12727 }
12728 GeneratedField::Version => {
12729 if version__.is_some() {
12730 return Err(serde::de::Error::duplicate_field("version"));
12731 }
12732 version__ = map_.next_value()?;
12733 }
12734 }
12735 }
12736 Ok(ResetSourceResponse {
12737 status: status__,
12738 version: version__,
12739 })
12740 }
12741 }
12742 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
12743 }
12744}
12745impl serde::Serialize for RisectlListStateTablesRequest {
12746 #[allow(deprecated)]
12747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12748 where
12749 S: serde::Serializer,
12750 {
12751 use serde::ser::SerializeStruct;
12752 let len = 0;
12753 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
12754 struct_ser.end()
12755 }
12756}
12757impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
12758 #[allow(deprecated)]
12759 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12760 where
12761 D: serde::Deserializer<'de>,
12762 {
12763 const FIELDS: &[&str] = &[
12764 ];
12765
12766 #[allow(clippy::enum_variant_names)]
12767 enum GeneratedField {
12768 }
12769 impl<'de> serde::Deserialize<'de> for GeneratedField {
12770 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12771 where
12772 D: serde::Deserializer<'de>,
12773 {
12774 struct GeneratedVisitor;
12775
12776 impl serde::de::Visitor<'_> for GeneratedVisitor {
12777 type Value = GeneratedField;
12778
12779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12780 write!(formatter, "expected one of: {:?}", &FIELDS)
12781 }
12782
12783 #[allow(unused_variables)]
12784 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12785 where
12786 E: serde::de::Error,
12787 {
12788 Err(serde::de::Error::unknown_field(value, FIELDS))
12789 }
12790 }
12791 deserializer.deserialize_identifier(GeneratedVisitor)
12792 }
12793 }
12794 struct GeneratedVisitor;
12795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12796 type Value = RisectlListStateTablesRequest;
12797
12798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12799 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
12800 }
12801
12802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
12803 where
12804 V: serde::de::MapAccess<'de>,
12805 {
12806 while map_.next_key::<GeneratedField>()?.is_some() {
12807 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12808 }
12809 Ok(RisectlListStateTablesRequest {
12810 })
12811 }
12812 }
12813 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
12814 }
12815}
12816impl serde::Serialize for RisectlListStateTablesResponse {
12817 #[allow(deprecated)]
12818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12819 where
12820 S: serde::Serializer,
12821 {
12822 use serde::ser::SerializeStruct;
12823 let mut len = 0;
12824 if !self.tables.is_empty() {
12825 len += 1;
12826 }
12827 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
12828 if !self.tables.is_empty() {
12829 struct_ser.serialize_field("tables", &self.tables)?;
12830 }
12831 struct_ser.end()
12832 }
12833}
12834impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
12835 #[allow(deprecated)]
12836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12837 where
12838 D: serde::Deserializer<'de>,
12839 {
12840 const FIELDS: &[&str] = &[
12841 "tables",
12842 ];
12843
12844 #[allow(clippy::enum_variant_names)]
12845 enum GeneratedField {
12846 Tables,
12847 }
12848 impl<'de> serde::Deserialize<'de> for GeneratedField {
12849 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12850 where
12851 D: serde::Deserializer<'de>,
12852 {
12853 struct GeneratedVisitor;
12854
12855 impl serde::de::Visitor<'_> for GeneratedVisitor {
12856 type Value = GeneratedField;
12857
12858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12859 write!(formatter, "expected one of: {:?}", &FIELDS)
12860 }
12861
12862 #[allow(unused_variables)]
12863 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12864 where
12865 E: serde::de::Error,
12866 {
12867 match value {
12868 "tables" => Ok(GeneratedField::Tables),
12869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12870 }
12871 }
12872 }
12873 deserializer.deserialize_identifier(GeneratedVisitor)
12874 }
12875 }
12876 struct GeneratedVisitor;
12877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12878 type Value = RisectlListStateTablesResponse;
12879
12880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12881 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
12882 }
12883
12884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
12885 where
12886 V: serde::de::MapAccess<'de>,
12887 {
12888 let mut tables__ = None;
12889 while let Some(k) = map_.next_key()? {
12890 match k {
12891 GeneratedField::Tables => {
12892 if tables__.is_some() {
12893 return Err(serde::de::Error::duplicate_field("tables"));
12894 }
12895 tables__ = Some(map_.next_value()?);
12896 }
12897 }
12898 }
12899 Ok(RisectlListStateTablesResponse {
12900 tables: tables__.unwrap_or_default(),
12901 })
12902 }
12903 }
12904 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
12905 }
12906}
12907impl serde::Serialize for RisectlResumeBackfillRequest {
12908 #[allow(deprecated)]
12909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12910 where
12911 S: serde::Serializer,
12912 {
12913 use serde::ser::SerializeStruct;
12914 let mut len = 0;
12915 if self.target.is_some() {
12916 len += 1;
12917 }
12918 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillRequest", len)?;
12919 if let Some(v) = self.target.as_ref() {
12920 match v {
12921 risectl_resume_backfill_request::Target::JobId(v) => {
12922 struct_ser.serialize_field("jobId", v)?;
12923 }
12924 risectl_resume_backfill_request::Target::FragmentId(v) => {
12925 struct_ser.serialize_field("fragmentId", v)?;
12926 }
12927 }
12928 }
12929 struct_ser.end()
12930 }
12931}
12932impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillRequest {
12933 #[allow(deprecated)]
12934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12935 where
12936 D: serde::Deserializer<'de>,
12937 {
12938 const FIELDS: &[&str] = &[
12939 "job_id",
12940 "jobId",
12941 "fragment_id",
12942 "fragmentId",
12943 ];
12944
12945 #[allow(clippy::enum_variant_names)]
12946 enum GeneratedField {
12947 JobId,
12948 FragmentId,
12949 }
12950 impl<'de> serde::Deserialize<'de> for GeneratedField {
12951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12952 where
12953 D: serde::Deserializer<'de>,
12954 {
12955 struct GeneratedVisitor;
12956
12957 impl serde::de::Visitor<'_> for GeneratedVisitor {
12958 type Value = GeneratedField;
12959
12960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12961 write!(formatter, "expected one of: {:?}", &FIELDS)
12962 }
12963
12964 #[allow(unused_variables)]
12965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12966 where
12967 E: serde::de::Error,
12968 {
12969 match value {
12970 "jobId" | "job_id" => Ok(GeneratedField::JobId),
12971 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12973 }
12974 }
12975 }
12976 deserializer.deserialize_identifier(GeneratedVisitor)
12977 }
12978 }
12979 struct GeneratedVisitor;
12980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12981 type Value = RisectlResumeBackfillRequest;
12982
12983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12984 formatter.write_str("struct ddl_service.RisectlResumeBackfillRequest")
12985 }
12986
12987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillRequest, V::Error>
12988 where
12989 V: serde::de::MapAccess<'de>,
12990 {
12991 let mut target__ = None;
12992 while let Some(k) = map_.next_key()? {
12993 match k {
12994 GeneratedField::JobId => {
12995 if target__.is_some() {
12996 return Err(serde::de::Error::duplicate_field("jobId"));
12997 }
12998 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::JobId(x.0));
12999 }
13000 GeneratedField::FragmentId => {
13001 if target__.is_some() {
13002 return Err(serde::de::Error::duplicate_field("fragmentId"));
13003 }
13004 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::FragmentId(x.0));
13005 }
13006 }
13007 }
13008 Ok(RisectlResumeBackfillRequest {
13009 target: target__,
13010 })
13011 }
13012 }
13013 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillRequest", FIELDS, GeneratedVisitor)
13014 }
13015}
13016impl serde::Serialize for RisectlResumeBackfillResponse {
13017 #[allow(deprecated)]
13018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13019 where
13020 S: serde::Serializer,
13021 {
13022 use serde::ser::SerializeStruct;
13023 let len = 0;
13024 let struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillResponse", len)?;
13025 struct_ser.end()
13026 }
13027}
13028impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillResponse {
13029 #[allow(deprecated)]
13030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13031 where
13032 D: serde::Deserializer<'de>,
13033 {
13034 const FIELDS: &[&str] = &[
13035 ];
13036
13037 #[allow(clippy::enum_variant_names)]
13038 enum GeneratedField {
13039 }
13040 impl<'de> serde::Deserialize<'de> for GeneratedField {
13041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13042 where
13043 D: serde::Deserializer<'de>,
13044 {
13045 struct GeneratedVisitor;
13046
13047 impl serde::de::Visitor<'_> for GeneratedVisitor {
13048 type Value = GeneratedField;
13049
13050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13051 write!(formatter, "expected one of: {:?}", &FIELDS)
13052 }
13053
13054 #[allow(unused_variables)]
13055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13056 where
13057 E: serde::de::Error,
13058 {
13059 Err(serde::de::Error::unknown_field(value, FIELDS))
13060 }
13061 }
13062 deserializer.deserialize_identifier(GeneratedVisitor)
13063 }
13064 }
13065 struct GeneratedVisitor;
13066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13067 type Value = RisectlResumeBackfillResponse;
13068
13069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13070 formatter.write_str("struct ddl_service.RisectlResumeBackfillResponse")
13071 }
13072
13073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillResponse, V::Error>
13074 where
13075 V: serde::de::MapAccess<'de>,
13076 {
13077 while map_.next_key::<GeneratedField>()?.is_some() {
13078 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13079 }
13080 Ok(RisectlResumeBackfillResponse {
13081 })
13082 }
13083 }
13084 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillResponse", FIELDS, GeneratedVisitor)
13085 }
13086}
13087impl serde::Serialize for SchemaChangeEnvelope {
13088 #[allow(deprecated)]
13089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13090 where
13091 S: serde::Serializer,
13092 {
13093 use serde::ser::SerializeStruct;
13094 let mut len = 0;
13095 if !self.table_changes.is_empty() {
13096 len += 1;
13097 }
13098 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
13099 if !self.table_changes.is_empty() {
13100 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
13101 }
13102 struct_ser.end()
13103 }
13104}
13105impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
13106 #[allow(deprecated)]
13107 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13108 where
13109 D: serde::Deserializer<'de>,
13110 {
13111 const FIELDS: &[&str] = &[
13112 "table_changes",
13113 "tableChanges",
13114 ];
13115
13116 #[allow(clippy::enum_variant_names)]
13117 enum GeneratedField {
13118 TableChanges,
13119 }
13120 impl<'de> serde::Deserialize<'de> for GeneratedField {
13121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13122 where
13123 D: serde::Deserializer<'de>,
13124 {
13125 struct GeneratedVisitor;
13126
13127 impl serde::de::Visitor<'_> for GeneratedVisitor {
13128 type Value = GeneratedField;
13129
13130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13131 write!(formatter, "expected one of: {:?}", &FIELDS)
13132 }
13133
13134 #[allow(unused_variables)]
13135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13136 where
13137 E: serde::de::Error,
13138 {
13139 match value {
13140 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
13141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13142 }
13143 }
13144 }
13145 deserializer.deserialize_identifier(GeneratedVisitor)
13146 }
13147 }
13148 struct GeneratedVisitor;
13149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13150 type Value = SchemaChangeEnvelope;
13151
13152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13153 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
13154 }
13155
13156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
13157 where
13158 V: serde::de::MapAccess<'de>,
13159 {
13160 let mut table_changes__ = None;
13161 while let Some(k) = map_.next_key()? {
13162 match k {
13163 GeneratedField::TableChanges => {
13164 if table_changes__.is_some() {
13165 return Err(serde::de::Error::duplicate_field("tableChanges"));
13166 }
13167 table_changes__ = Some(map_.next_value()?);
13168 }
13169 }
13170 }
13171 Ok(SchemaChangeEnvelope {
13172 table_changes: table_changes__.unwrap_or_default(),
13173 })
13174 }
13175 }
13176 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
13177 }
13178}
13179impl serde::Serialize for StreamingJobResourceType {
13180 #[allow(deprecated)]
13181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13182 where
13183 S: serde::Serializer,
13184 {
13185 use serde::ser::SerializeStruct;
13186 let mut len = 0;
13187 if self.resource_type.is_some() {
13188 len += 1;
13189 }
13190 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
13191 if let Some(v) = self.resource_type.as_ref() {
13192 match v {
13193 streaming_job_resource_type::ResourceType::Regular(v) => {
13194 struct_ser.serialize_field("regular", v)?;
13195 }
13196 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
13197 struct_ser.serialize_field("specificResourceGroup", v)?;
13198 }
13199 streaming_job_resource_type::ResourceType::ServerlessBackfill(v) => {
13200 struct_ser.serialize_field("serverlessBackfill", v)?;
13201 }
13202 }
13203 }
13204 struct_ser.end()
13205 }
13206}
13207impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
13208 #[allow(deprecated)]
13209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13210 where
13211 D: serde::Deserializer<'de>,
13212 {
13213 const FIELDS: &[&str] = &[
13214 "regular",
13215 "specific_resource_group",
13216 "specificResourceGroup",
13217 "serverless_backfill",
13218 "serverlessBackfill",
13219 ];
13220
13221 #[allow(clippy::enum_variant_names)]
13222 enum GeneratedField {
13223 Regular,
13224 SpecificResourceGroup,
13225 ServerlessBackfill,
13226 }
13227 impl<'de> serde::Deserialize<'de> for GeneratedField {
13228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13229 where
13230 D: serde::Deserializer<'de>,
13231 {
13232 struct GeneratedVisitor;
13233
13234 impl serde::de::Visitor<'_> for GeneratedVisitor {
13235 type Value = GeneratedField;
13236
13237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13238 write!(formatter, "expected one of: {:?}", &FIELDS)
13239 }
13240
13241 #[allow(unused_variables)]
13242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13243 where
13244 E: serde::de::Error,
13245 {
13246 match value {
13247 "regular" => Ok(GeneratedField::Regular),
13248 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
13249 "serverlessBackfill" | "serverless_backfill" => Ok(GeneratedField::ServerlessBackfill),
13250 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13251 }
13252 }
13253 }
13254 deserializer.deserialize_identifier(GeneratedVisitor)
13255 }
13256 }
13257 struct GeneratedVisitor;
13258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13259 type Value = StreamingJobResourceType;
13260
13261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13262 formatter.write_str("struct ddl_service.StreamingJobResourceType")
13263 }
13264
13265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
13266 where
13267 V: serde::de::MapAccess<'de>,
13268 {
13269 let mut resource_type__ = None;
13270 while let Some(k) = map_.next_key()? {
13271 match k {
13272 GeneratedField::Regular => {
13273 if resource_type__.is_some() {
13274 return Err(serde::de::Error::duplicate_field("regular"));
13275 }
13276 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
13277 }
13278 GeneratedField::SpecificResourceGroup => {
13279 if resource_type__.is_some() {
13280 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
13281 }
13282 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
13283 }
13284 GeneratedField::ServerlessBackfill => {
13285 if resource_type__.is_some() {
13286 return Err(serde::de::Error::duplicate_field("serverlessBackfill"));
13287 }
13288 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfill);
13289 }
13290 }
13291 }
13292 Ok(StreamingJobResourceType {
13293 resource_type: resource_type__,
13294 })
13295 }
13296 }
13297 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
13298 }
13299}
13300impl serde::Serialize for TableJobType {
13301 #[allow(deprecated)]
13302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13303 where
13304 S: serde::Serializer,
13305 {
13306 let variant = match self {
13307 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
13308 Self::General => "TABLE_JOB_TYPE_GENERAL",
13309 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
13310 };
13311 serializer.serialize_str(variant)
13312 }
13313}
13314impl<'de> serde::Deserialize<'de> for TableJobType {
13315 #[allow(deprecated)]
13316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13317 where
13318 D: serde::Deserializer<'de>,
13319 {
13320 const FIELDS: &[&str] = &[
13321 "TABLE_JOB_TYPE_UNSPECIFIED",
13322 "TABLE_JOB_TYPE_GENERAL",
13323 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
13324 ];
13325
13326 struct GeneratedVisitor;
13327
13328 impl serde::de::Visitor<'_> for GeneratedVisitor {
13329 type Value = TableJobType;
13330
13331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13332 write!(formatter, "expected one of: {:?}", &FIELDS)
13333 }
13334
13335 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13336 where
13337 E: serde::de::Error,
13338 {
13339 i32::try_from(v)
13340 .ok()
13341 .and_then(|x| x.try_into().ok())
13342 .ok_or_else(|| {
13343 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13344 })
13345 }
13346
13347 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13348 where
13349 E: serde::de::Error,
13350 {
13351 i32::try_from(v)
13352 .ok()
13353 .and_then(|x| x.try_into().ok())
13354 .ok_or_else(|| {
13355 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13356 })
13357 }
13358
13359 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13360 where
13361 E: serde::de::Error,
13362 {
13363 match value {
13364 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
13365 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
13366 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
13367 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13368 }
13369 }
13370 }
13371 deserializer.deserialize_any(GeneratedVisitor)
13372 }
13373}
13374impl serde::Serialize for TableSchemaChange {
13375 #[allow(deprecated)]
13376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13377 where
13378 S: serde::Serializer,
13379 {
13380 use serde::ser::SerializeStruct;
13381 let mut len = 0;
13382 if self.change_type != 0 {
13383 len += 1;
13384 }
13385 if !self.cdc_table_id.is_empty() {
13386 len += 1;
13387 }
13388 if !self.columns.is_empty() {
13389 len += 1;
13390 }
13391 if !self.upstream_ddl.is_empty() {
13392 len += 1;
13393 }
13394 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
13395 if self.change_type != 0 {
13396 let v = table_schema_change::TableChangeType::try_from(self.change_type)
13397 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
13398 struct_ser.serialize_field("changeType", &v)?;
13399 }
13400 if !self.cdc_table_id.is_empty() {
13401 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
13402 }
13403 if !self.columns.is_empty() {
13404 struct_ser.serialize_field("columns", &self.columns)?;
13405 }
13406 if !self.upstream_ddl.is_empty() {
13407 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
13408 }
13409 struct_ser.end()
13410 }
13411}
13412impl<'de> serde::Deserialize<'de> for TableSchemaChange {
13413 #[allow(deprecated)]
13414 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13415 where
13416 D: serde::Deserializer<'de>,
13417 {
13418 const FIELDS: &[&str] = &[
13419 "change_type",
13420 "changeType",
13421 "cdc_table_id",
13422 "cdcTableId",
13423 "columns",
13424 "upstream_ddl",
13425 "upstreamDdl",
13426 ];
13427
13428 #[allow(clippy::enum_variant_names)]
13429 enum GeneratedField {
13430 ChangeType,
13431 CdcTableId,
13432 Columns,
13433 UpstreamDdl,
13434 }
13435 impl<'de> serde::Deserialize<'de> for GeneratedField {
13436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13437 where
13438 D: serde::Deserializer<'de>,
13439 {
13440 struct GeneratedVisitor;
13441
13442 impl serde::de::Visitor<'_> for GeneratedVisitor {
13443 type Value = GeneratedField;
13444
13445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13446 write!(formatter, "expected one of: {:?}", &FIELDS)
13447 }
13448
13449 #[allow(unused_variables)]
13450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13451 where
13452 E: serde::de::Error,
13453 {
13454 match value {
13455 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
13456 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
13457 "columns" => Ok(GeneratedField::Columns),
13458 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
13459 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13460 }
13461 }
13462 }
13463 deserializer.deserialize_identifier(GeneratedVisitor)
13464 }
13465 }
13466 struct GeneratedVisitor;
13467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13468 type Value = TableSchemaChange;
13469
13470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13471 formatter.write_str("struct ddl_service.TableSchemaChange")
13472 }
13473
13474 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
13475 where
13476 V: serde::de::MapAccess<'de>,
13477 {
13478 let mut change_type__ = None;
13479 let mut cdc_table_id__ = None;
13480 let mut columns__ = None;
13481 let mut upstream_ddl__ = None;
13482 while let Some(k) = map_.next_key()? {
13483 match k {
13484 GeneratedField::ChangeType => {
13485 if change_type__.is_some() {
13486 return Err(serde::de::Error::duplicate_field("changeType"));
13487 }
13488 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
13489 }
13490 GeneratedField::CdcTableId => {
13491 if cdc_table_id__.is_some() {
13492 return Err(serde::de::Error::duplicate_field("cdcTableId"));
13493 }
13494 cdc_table_id__ = Some(map_.next_value()?);
13495 }
13496 GeneratedField::Columns => {
13497 if columns__.is_some() {
13498 return Err(serde::de::Error::duplicate_field("columns"));
13499 }
13500 columns__ = Some(map_.next_value()?);
13501 }
13502 GeneratedField::UpstreamDdl => {
13503 if upstream_ddl__.is_some() {
13504 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
13505 }
13506 upstream_ddl__ = Some(map_.next_value()?);
13507 }
13508 }
13509 }
13510 Ok(TableSchemaChange {
13511 change_type: change_type__.unwrap_or_default(),
13512 cdc_table_id: cdc_table_id__.unwrap_or_default(),
13513 columns: columns__.unwrap_or_default(),
13514 upstream_ddl: upstream_ddl__.unwrap_or_default(),
13515 })
13516 }
13517 }
13518 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
13519 }
13520}
13521impl serde::Serialize for table_schema_change::TableChangeType {
13522 #[allow(deprecated)]
13523 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13524 where
13525 S: serde::Serializer,
13526 {
13527 let variant = match self {
13528 Self::Unspecified => "UNSPECIFIED",
13529 Self::Alter => "ALTER",
13530 Self::Create => "CREATE",
13531 Self::Drop => "DROP",
13532 };
13533 serializer.serialize_str(variant)
13534 }
13535}
13536impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
13537 #[allow(deprecated)]
13538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13539 where
13540 D: serde::Deserializer<'de>,
13541 {
13542 const FIELDS: &[&str] = &[
13543 "UNSPECIFIED",
13544 "ALTER",
13545 "CREATE",
13546 "DROP",
13547 ];
13548
13549 struct GeneratedVisitor;
13550
13551 impl serde::de::Visitor<'_> for GeneratedVisitor {
13552 type Value = table_schema_change::TableChangeType;
13553
13554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13555 write!(formatter, "expected one of: {:?}", &FIELDS)
13556 }
13557
13558 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13559 where
13560 E: serde::de::Error,
13561 {
13562 i32::try_from(v)
13563 .ok()
13564 .and_then(|x| x.try_into().ok())
13565 .ok_or_else(|| {
13566 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13567 })
13568 }
13569
13570 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13571 where
13572 E: serde::de::Error,
13573 {
13574 i32::try_from(v)
13575 .ok()
13576 .and_then(|x| x.try_into().ok())
13577 .ok_or_else(|| {
13578 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13579 })
13580 }
13581
13582 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13583 where
13584 E: serde::de::Error,
13585 {
13586 match value {
13587 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
13588 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
13589 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
13590 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
13591 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13592 }
13593 }
13594 }
13595 deserializer.deserialize_any(GeneratedVisitor)
13596 }
13597}
13598impl serde::Serialize for WaitRequest {
13599 #[allow(deprecated)]
13600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13601 where
13602 S: serde::Serializer,
13603 {
13604 use serde::ser::SerializeStruct;
13605 let mut len = 0;
13606 if self.job_id.is_some() {
13607 len += 1;
13608 }
13609 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
13610 if let Some(v) = self.job_id.as_ref() {
13611 struct_ser.serialize_field("jobId", v)?;
13612 }
13613 struct_ser.end()
13614 }
13615}
13616impl<'de> serde::Deserialize<'de> for WaitRequest {
13617 #[allow(deprecated)]
13618 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13619 where
13620 D: serde::Deserializer<'de>,
13621 {
13622 const FIELDS: &[&str] = &[
13623 "job_id",
13624 "jobId",
13625 ];
13626
13627 #[allow(clippy::enum_variant_names)]
13628 enum GeneratedField {
13629 JobId,
13630 }
13631 impl<'de> serde::Deserialize<'de> for GeneratedField {
13632 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13633 where
13634 D: serde::Deserializer<'de>,
13635 {
13636 struct GeneratedVisitor;
13637
13638 impl serde::de::Visitor<'_> for GeneratedVisitor {
13639 type Value = GeneratedField;
13640
13641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13642 write!(formatter, "expected one of: {:?}", &FIELDS)
13643 }
13644
13645 #[allow(unused_variables)]
13646 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13647 where
13648 E: serde::de::Error,
13649 {
13650 match value {
13651 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13653 }
13654 }
13655 }
13656 deserializer.deserialize_identifier(GeneratedVisitor)
13657 }
13658 }
13659 struct GeneratedVisitor;
13660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13661 type Value = WaitRequest;
13662
13663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13664 formatter.write_str("struct ddl_service.WaitRequest")
13665 }
13666
13667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
13668 where
13669 V: serde::de::MapAccess<'de>,
13670 {
13671 let mut job_id__ = None;
13672 while let Some(k) = map_.next_key()? {
13673 match k {
13674 GeneratedField::JobId => {
13675 if job_id__.is_some() {
13676 return Err(serde::de::Error::duplicate_field("jobId"));
13677 }
13678 job_id__ =
13679 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13680 ;
13681 }
13682 }
13683 }
13684 Ok(WaitRequest {
13685 job_id: job_id__,
13686 })
13687 }
13688 }
13689 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
13690 }
13691}
13692impl serde::Serialize for WaitResponse {
13693 #[allow(deprecated)]
13694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13695 where
13696 S: serde::Serializer,
13697 {
13698 use serde::ser::SerializeStruct;
13699 let mut len = 0;
13700 if self.version.is_some() {
13701 len += 1;
13702 }
13703 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
13704 if let Some(v) = self.version.as_ref() {
13705 struct_ser.serialize_field("version", v)?;
13706 }
13707 struct_ser.end()
13708 }
13709}
13710impl<'de> serde::Deserialize<'de> for WaitResponse {
13711 #[allow(deprecated)]
13712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13713 where
13714 D: serde::Deserializer<'de>,
13715 {
13716 const FIELDS: &[&str] = &[
13717 "version",
13718 ];
13719
13720 #[allow(clippy::enum_variant_names)]
13721 enum GeneratedField {
13722 Version,
13723 }
13724 impl<'de> serde::Deserialize<'de> for GeneratedField {
13725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13726 where
13727 D: serde::Deserializer<'de>,
13728 {
13729 struct GeneratedVisitor;
13730
13731 impl serde::de::Visitor<'_> for GeneratedVisitor {
13732 type Value = GeneratedField;
13733
13734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13735 write!(formatter, "expected one of: {:?}", &FIELDS)
13736 }
13737
13738 #[allow(unused_variables)]
13739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13740 where
13741 E: serde::de::Error,
13742 {
13743 match value {
13744 "version" => Ok(GeneratedField::Version),
13745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13746 }
13747 }
13748 }
13749 deserializer.deserialize_identifier(GeneratedVisitor)
13750 }
13751 }
13752 struct GeneratedVisitor;
13753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13754 type Value = WaitResponse;
13755
13756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13757 formatter.write_str("struct ddl_service.WaitResponse")
13758 }
13759
13760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
13761 where
13762 V: serde::de::MapAccess<'de>,
13763 {
13764 let mut version__ = None;
13765 while let Some(k) = map_.next_key()? {
13766 match k {
13767 GeneratedField::Version => {
13768 if version__.is_some() {
13769 return Err(serde::de::Error::duplicate_field("version"));
13770 }
13771 version__ = map_.next_value()?;
13772 }
13773 }
13774 }
13775 Ok(WaitResponse {
13776 version: version__,
13777 })
13778 }
13779 }
13780 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
13781 }
13782}
13783impl serde::Serialize for WaitVersion {
13784 #[allow(deprecated)]
13785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13786 where
13787 S: serde::Serializer,
13788 {
13789 use serde::ser::SerializeStruct;
13790 let mut len = 0;
13791 if self.catalog_version != 0 {
13792 len += 1;
13793 }
13794 if self.hummock_version_id != 0 {
13795 len += 1;
13796 }
13797 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
13798 if self.catalog_version != 0 {
13799 #[allow(clippy::needless_borrow)]
13800 #[allow(clippy::needless_borrows_for_generic_args)]
13801 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13802 }
13803 if self.hummock_version_id != 0 {
13804 #[allow(clippy::needless_borrow)]
13805 #[allow(clippy::needless_borrows_for_generic_args)]
13806 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
13807 }
13808 struct_ser.end()
13809 }
13810}
13811impl<'de> serde::Deserialize<'de> for WaitVersion {
13812 #[allow(deprecated)]
13813 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13814 where
13815 D: serde::Deserializer<'de>,
13816 {
13817 const FIELDS: &[&str] = &[
13818 "catalog_version",
13819 "catalogVersion",
13820 "hummock_version_id",
13821 "hummockVersionId",
13822 ];
13823
13824 #[allow(clippy::enum_variant_names)]
13825 enum GeneratedField {
13826 CatalogVersion,
13827 HummockVersionId,
13828 }
13829 impl<'de> serde::Deserialize<'de> for GeneratedField {
13830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13831 where
13832 D: serde::Deserializer<'de>,
13833 {
13834 struct GeneratedVisitor;
13835
13836 impl serde::de::Visitor<'_> for GeneratedVisitor {
13837 type Value = GeneratedField;
13838
13839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13840 write!(formatter, "expected one of: {:?}", &FIELDS)
13841 }
13842
13843 #[allow(unused_variables)]
13844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13845 where
13846 E: serde::de::Error,
13847 {
13848 match value {
13849 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13850 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
13851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13852 }
13853 }
13854 }
13855 deserializer.deserialize_identifier(GeneratedVisitor)
13856 }
13857 }
13858 struct GeneratedVisitor;
13859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13860 type Value = WaitVersion;
13861
13862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13863 formatter.write_str("struct ddl_service.WaitVersion")
13864 }
13865
13866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
13867 where
13868 V: serde::de::MapAccess<'de>,
13869 {
13870 let mut catalog_version__ = None;
13871 let mut hummock_version_id__ = None;
13872 while let Some(k) = map_.next_key()? {
13873 match k {
13874 GeneratedField::CatalogVersion => {
13875 if catalog_version__.is_some() {
13876 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13877 }
13878 catalog_version__ =
13879 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13880 ;
13881 }
13882 GeneratedField::HummockVersionId => {
13883 if hummock_version_id__.is_some() {
13884 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
13885 }
13886 hummock_version_id__ =
13887 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13888 ;
13889 }
13890 }
13891 }
13892 Ok(WaitVersion {
13893 catalog_version: catalog_version__.unwrap_or_default(),
13894 hummock_version_id: hummock_version_id__.unwrap_or_default(),
13895 })
13896 }
13897 }
13898 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
13899 }
13900}