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 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
6754 if let Some(v) = self.sink.as_ref() {
6755 struct_ser.serialize_field("sink", v)?;
6756 }
6757 if let Some(v) = self.fragment_graph.as_ref() {
6758 struct_ser.serialize_field("fragmentGraph", v)?;
6759 }
6760 if !self.dependencies.is_empty() {
6761 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6762 }
6763 if self.if_not_exists {
6764 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6765 }
6766 if let Some(v) = self.resource_type.as_ref() {
6767 struct_ser.serialize_field("resourceType", v)?;
6768 }
6769 struct_ser.end()
6770 }
6771}
6772impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6773 #[allow(deprecated)]
6774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6775 where
6776 D: serde::Deserializer<'de>,
6777 {
6778 const FIELDS: &[&str] = &[
6779 "sink",
6780 "fragment_graph",
6781 "fragmentGraph",
6782 "dependencies",
6783 "if_not_exists",
6784 "ifNotExists",
6785 "resource_type",
6786 "resourceType",
6787 ];
6788
6789 #[allow(clippy::enum_variant_names)]
6790 enum GeneratedField {
6791 Sink,
6792 FragmentGraph,
6793 Dependencies,
6794 IfNotExists,
6795 ResourceType,
6796 }
6797 impl<'de> serde::Deserialize<'de> for GeneratedField {
6798 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6799 where
6800 D: serde::Deserializer<'de>,
6801 {
6802 struct GeneratedVisitor;
6803
6804 impl serde::de::Visitor<'_> for GeneratedVisitor {
6805 type Value = GeneratedField;
6806
6807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6808 write!(formatter, "expected one of: {:?}", &FIELDS)
6809 }
6810
6811 #[allow(unused_variables)]
6812 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6813 where
6814 E: serde::de::Error,
6815 {
6816 match value {
6817 "sink" => Ok(GeneratedField::Sink),
6818 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6819 "dependencies" => Ok(GeneratedField::Dependencies),
6820 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6821 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
6822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6823 }
6824 }
6825 }
6826 deserializer.deserialize_identifier(GeneratedVisitor)
6827 }
6828 }
6829 struct GeneratedVisitor;
6830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6831 type Value = CreateSinkRequest;
6832
6833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6834 formatter.write_str("struct ddl_service.CreateSinkRequest")
6835 }
6836
6837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6838 where
6839 V: serde::de::MapAccess<'de>,
6840 {
6841 let mut sink__ = None;
6842 let mut fragment_graph__ = None;
6843 let mut dependencies__ = None;
6844 let mut if_not_exists__ = None;
6845 let mut resource_type__ = None;
6846 while let Some(k) = map_.next_key()? {
6847 match k {
6848 GeneratedField::Sink => {
6849 if sink__.is_some() {
6850 return Err(serde::de::Error::duplicate_field("sink"));
6851 }
6852 sink__ = map_.next_value()?;
6853 }
6854 GeneratedField::FragmentGraph => {
6855 if fragment_graph__.is_some() {
6856 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6857 }
6858 fragment_graph__ = map_.next_value()?;
6859 }
6860 GeneratedField::Dependencies => {
6861 if dependencies__.is_some() {
6862 return Err(serde::de::Error::duplicate_field("dependencies"));
6863 }
6864 dependencies__ =
6865 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6866 .into_iter().map(|x| x.0).collect())
6867 ;
6868 }
6869 GeneratedField::IfNotExists => {
6870 if if_not_exists__.is_some() {
6871 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6872 }
6873 if_not_exists__ = Some(map_.next_value()?);
6874 }
6875 GeneratedField::ResourceType => {
6876 if resource_type__.is_some() {
6877 return Err(serde::de::Error::duplicate_field("resourceType"));
6878 }
6879 resource_type__ = map_.next_value()?;
6880 }
6881 }
6882 }
6883 Ok(CreateSinkRequest {
6884 sink: sink__,
6885 fragment_graph: fragment_graph__,
6886 dependencies: dependencies__.unwrap_or_default(),
6887 if_not_exists: if_not_exists__.unwrap_or_default(),
6888 resource_type: resource_type__,
6889 })
6890 }
6891 }
6892 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6893 }
6894}
6895impl serde::Serialize for CreateSinkResponse {
6896 #[allow(deprecated)]
6897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6898 where
6899 S: serde::Serializer,
6900 {
6901 use serde::ser::SerializeStruct;
6902 let mut len = 0;
6903 if self.status.is_some() {
6904 len += 1;
6905 }
6906 if self.version.is_some() {
6907 len += 1;
6908 }
6909 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6910 if let Some(v) = self.status.as_ref() {
6911 struct_ser.serialize_field("status", v)?;
6912 }
6913 if let Some(v) = self.version.as_ref() {
6914 struct_ser.serialize_field("version", v)?;
6915 }
6916 struct_ser.end()
6917 }
6918}
6919impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6920 #[allow(deprecated)]
6921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6922 where
6923 D: serde::Deserializer<'de>,
6924 {
6925 const FIELDS: &[&str] = &[
6926 "status",
6927 "version",
6928 ];
6929
6930 #[allow(clippy::enum_variant_names)]
6931 enum GeneratedField {
6932 Status,
6933 Version,
6934 }
6935 impl<'de> serde::Deserialize<'de> for GeneratedField {
6936 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6937 where
6938 D: serde::Deserializer<'de>,
6939 {
6940 struct GeneratedVisitor;
6941
6942 impl serde::de::Visitor<'_> for GeneratedVisitor {
6943 type Value = GeneratedField;
6944
6945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6946 write!(formatter, "expected one of: {:?}", &FIELDS)
6947 }
6948
6949 #[allow(unused_variables)]
6950 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6951 where
6952 E: serde::de::Error,
6953 {
6954 match value {
6955 "status" => Ok(GeneratedField::Status),
6956 "version" => Ok(GeneratedField::Version),
6957 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6958 }
6959 }
6960 }
6961 deserializer.deserialize_identifier(GeneratedVisitor)
6962 }
6963 }
6964 struct GeneratedVisitor;
6965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6966 type Value = CreateSinkResponse;
6967
6968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6969 formatter.write_str("struct ddl_service.CreateSinkResponse")
6970 }
6971
6972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6973 where
6974 V: serde::de::MapAccess<'de>,
6975 {
6976 let mut status__ = None;
6977 let mut version__ = None;
6978 while let Some(k) = map_.next_key()? {
6979 match k {
6980 GeneratedField::Status => {
6981 if status__.is_some() {
6982 return Err(serde::de::Error::duplicate_field("status"));
6983 }
6984 status__ = map_.next_value()?;
6985 }
6986 GeneratedField::Version => {
6987 if version__.is_some() {
6988 return Err(serde::de::Error::duplicate_field("version"));
6989 }
6990 version__ = map_.next_value()?;
6991 }
6992 }
6993 }
6994 Ok(CreateSinkResponse {
6995 status: status__,
6996 version: version__,
6997 })
6998 }
6999 }
7000 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
7001 }
7002}
7003impl serde::Serialize for CreateSourceRequest {
7004 #[allow(deprecated)]
7005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7006 where
7007 S: serde::Serializer,
7008 {
7009 use serde::ser::SerializeStruct;
7010 let mut len = 0;
7011 if self.source.is_some() {
7012 len += 1;
7013 }
7014 if self.fragment_graph.is_some() {
7015 len += 1;
7016 }
7017 if self.if_not_exists {
7018 len += 1;
7019 }
7020 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
7021 if let Some(v) = self.source.as_ref() {
7022 struct_ser.serialize_field("source", v)?;
7023 }
7024 if let Some(v) = self.fragment_graph.as_ref() {
7025 struct_ser.serialize_field("fragmentGraph", v)?;
7026 }
7027 if self.if_not_exists {
7028 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7029 }
7030 struct_ser.end()
7031 }
7032}
7033impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
7034 #[allow(deprecated)]
7035 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7036 where
7037 D: serde::Deserializer<'de>,
7038 {
7039 const FIELDS: &[&str] = &[
7040 "source",
7041 "fragment_graph",
7042 "fragmentGraph",
7043 "if_not_exists",
7044 "ifNotExists",
7045 ];
7046
7047 #[allow(clippy::enum_variant_names)]
7048 enum GeneratedField {
7049 Source,
7050 FragmentGraph,
7051 IfNotExists,
7052 }
7053 impl<'de> serde::Deserialize<'de> for GeneratedField {
7054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7055 where
7056 D: serde::Deserializer<'de>,
7057 {
7058 struct GeneratedVisitor;
7059
7060 impl serde::de::Visitor<'_> for GeneratedVisitor {
7061 type Value = GeneratedField;
7062
7063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7064 write!(formatter, "expected one of: {:?}", &FIELDS)
7065 }
7066
7067 #[allow(unused_variables)]
7068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7069 where
7070 E: serde::de::Error,
7071 {
7072 match value {
7073 "source" => Ok(GeneratedField::Source),
7074 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7075 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7077 }
7078 }
7079 }
7080 deserializer.deserialize_identifier(GeneratedVisitor)
7081 }
7082 }
7083 struct GeneratedVisitor;
7084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7085 type Value = CreateSourceRequest;
7086
7087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7088 formatter.write_str("struct ddl_service.CreateSourceRequest")
7089 }
7090
7091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
7092 where
7093 V: serde::de::MapAccess<'de>,
7094 {
7095 let mut source__ = None;
7096 let mut fragment_graph__ = None;
7097 let mut if_not_exists__ = None;
7098 while let Some(k) = map_.next_key()? {
7099 match k {
7100 GeneratedField::Source => {
7101 if source__.is_some() {
7102 return Err(serde::de::Error::duplicate_field("source"));
7103 }
7104 source__ = map_.next_value()?;
7105 }
7106 GeneratedField::FragmentGraph => {
7107 if fragment_graph__.is_some() {
7108 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7109 }
7110 fragment_graph__ = map_.next_value()?;
7111 }
7112 GeneratedField::IfNotExists => {
7113 if if_not_exists__.is_some() {
7114 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7115 }
7116 if_not_exists__ = Some(map_.next_value()?);
7117 }
7118 }
7119 }
7120 Ok(CreateSourceRequest {
7121 source: source__,
7122 fragment_graph: fragment_graph__,
7123 if_not_exists: if_not_exists__.unwrap_or_default(),
7124 })
7125 }
7126 }
7127 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
7128 }
7129}
7130impl serde::Serialize for CreateSourceResponse {
7131 #[allow(deprecated)]
7132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7133 where
7134 S: serde::Serializer,
7135 {
7136 use serde::ser::SerializeStruct;
7137 let mut len = 0;
7138 if self.status.is_some() {
7139 len += 1;
7140 }
7141 if self.version.is_some() {
7142 len += 1;
7143 }
7144 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
7145 if let Some(v) = self.status.as_ref() {
7146 struct_ser.serialize_field("status", v)?;
7147 }
7148 if let Some(v) = self.version.as_ref() {
7149 struct_ser.serialize_field("version", v)?;
7150 }
7151 struct_ser.end()
7152 }
7153}
7154impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
7155 #[allow(deprecated)]
7156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7157 where
7158 D: serde::Deserializer<'de>,
7159 {
7160 const FIELDS: &[&str] = &[
7161 "status",
7162 "version",
7163 ];
7164
7165 #[allow(clippy::enum_variant_names)]
7166 enum GeneratedField {
7167 Status,
7168 Version,
7169 }
7170 impl<'de> serde::Deserialize<'de> for GeneratedField {
7171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7172 where
7173 D: serde::Deserializer<'de>,
7174 {
7175 struct GeneratedVisitor;
7176
7177 impl serde::de::Visitor<'_> for GeneratedVisitor {
7178 type Value = GeneratedField;
7179
7180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7181 write!(formatter, "expected one of: {:?}", &FIELDS)
7182 }
7183
7184 #[allow(unused_variables)]
7185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7186 where
7187 E: serde::de::Error,
7188 {
7189 match value {
7190 "status" => Ok(GeneratedField::Status),
7191 "version" => Ok(GeneratedField::Version),
7192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7193 }
7194 }
7195 }
7196 deserializer.deserialize_identifier(GeneratedVisitor)
7197 }
7198 }
7199 struct GeneratedVisitor;
7200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7201 type Value = CreateSourceResponse;
7202
7203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7204 formatter.write_str("struct ddl_service.CreateSourceResponse")
7205 }
7206
7207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
7208 where
7209 V: serde::de::MapAccess<'de>,
7210 {
7211 let mut status__ = None;
7212 let mut version__ = None;
7213 while let Some(k) = map_.next_key()? {
7214 match k {
7215 GeneratedField::Status => {
7216 if status__.is_some() {
7217 return Err(serde::de::Error::duplicate_field("status"));
7218 }
7219 status__ = map_.next_value()?;
7220 }
7221 GeneratedField::Version => {
7222 if version__.is_some() {
7223 return Err(serde::de::Error::duplicate_field("version"));
7224 }
7225 version__ = map_.next_value()?;
7226 }
7227 }
7228 }
7229 Ok(CreateSourceResponse {
7230 status: status__,
7231 version: version__,
7232 })
7233 }
7234 }
7235 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
7236 }
7237}
7238impl serde::Serialize for CreateSubscriptionRequest {
7239 #[allow(deprecated)]
7240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7241 where
7242 S: serde::Serializer,
7243 {
7244 use serde::ser::SerializeStruct;
7245 let mut len = 0;
7246 if self.subscription.is_some() {
7247 len += 1;
7248 }
7249 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
7250 if let Some(v) = self.subscription.as_ref() {
7251 struct_ser.serialize_field("subscription", v)?;
7252 }
7253 struct_ser.end()
7254 }
7255}
7256impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
7257 #[allow(deprecated)]
7258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7259 where
7260 D: serde::Deserializer<'de>,
7261 {
7262 const FIELDS: &[&str] = &[
7263 "subscription",
7264 ];
7265
7266 #[allow(clippy::enum_variant_names)]
7267 enum GeneratedField {
7268 Subscription,
7269 }
7270 impl<'de> serde::Deserialize<'de> for GeneratedField {
7271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7272 where
7273 D: serde::Deserializer<'de>,
7274 {
7275 struct GeneratedVisitor;
7276
7277 impl serde::de::Visitor<'_> for GeneratedVisitor {
7278 type Value = GeneratedField;
7279
7280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7281 write!(formatter, "expected one of: {:?}", &FIELDS)
7282 }
7283
7284 #[allow(unused_variables)]
7285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7286 where
7287 E: serde::de::Error,
7288 {
7289 match value {
7290 "subscription" => Ok(GeneratedField::Subscription),
7291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7292 }
7293 }
7294 }
7295 deserializer.deserialize_identifier(GeneratedVisitor)
7296 }
7297 }
7298 struct GeneratedVisitor;
7299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7300 type Value = CreateSubscriptionRequest;
7301
7302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7303 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
7304 }
7305
7306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
7307 where
7308 V: serde::de::MapAccess<'de>,
7309 {
7310 let mut subscription__ = None;
7311 while let Some(k) = map_.next_key()? {
7312 match k {
7313 GeneratedField::Subscription => {
7314 if subscription__.is_some() {
7315 return Err(serde::de::Error::duplicate_field("subscription"));
7316 }
7317 subscription__ = map_.next_value()?;
7318 }
7319 }
7320 }
7321 Ok(CreateSubscriptionRequest {
7322 subscription: subscription__,
7323 })
7324 }
7325 }
7326 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
7327 }
7328}
7329impl serde::Serialize for CreateSubscriptionResponse {
7330 #[allow(deprecated)]
7331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7332 where
7333 S: serde::Serializer,
7334 {
7335 use serde::ser::SerializeStruct;
7336 let mut len = 0;
7337 if self.status.is_some() {
7338 len += 1;
7339 }
7340 if self.version.is_some() {
7341 len += 1;
7342 }
7343 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
7344 if let Some(v) = self.status.as_ref() {
7345 struct_ser.serialize_field("status", v)?;
7346 }
7347 if let Some(v) = self.version.as_ref() {
7348 struct_ser.serialize_field("version", v)?;
7349 }
7350 struct_ser.end()
7351 }
7352}
7353impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
7354 #[allow(deprecated)]
7355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7356 where
7357 D: serde::Deserializer<'de>,
7358 {
7359 const FIELDS: &[&str] = &[
7360 "status",
7361 "version",
7362 ];
7363
7364 #[allow(clippy::enum_variant_names)]
7365 enum GeneratedField {
7366 Status,
7367 Version,
7368 }
7369 impl<'de> serde::Deserialize<'de> for GeneratedField {
7370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7371 where
7372 D: serde::Deserializer<'de>,
7373 {
7374 struct GeneratedVisitor;
7375
7376 impl serde::de::Visitor<'_> for GeneratedVisitor {
7377 type Value = GeneratedField;
7378
7379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7380 write!(formatter, "expected one of: {:?}", &FIELDS)
7381 }
7382
7383 #[allow(unused_variables)]
7384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7385 where
7386 E: serde::de::Error,
7387 {
7388 match value {
7389 "status" => Ok(GeneratedField::Status),
7390 "version" => Ok(GeneratedField::Version),
7391 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7392 }
7393 }
7394 }
7395 deserializer.deserialize_identifier(GeneratedVisitor)
7396 }
7397 }
7398 struct GeneratedVisitor;
7399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7400 type Value = CreateSubscriptionResponse;
7401
7402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7403 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
7404 }
7405
7406 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
7407 where
7408 V: serde::de::MapAccess<'de>,
7409 {
7410 let mut status__ = None;
7411 let mut version__ = None;
7412 while let Some(k) = map_.next_key()? {
7413 match k {
7414 GeneratedField::Status => {
7415 if status__.is_some() {
7416 return Err(serde::de::Error::duplicate_field("status"));
7417 }
7418 status__ = map_.next_value()?;
7419 }
7420 GeneratedField::Version => {
7421 if version__.is_some() {
7422 return Err(serde::de::Error::duplicate_field("version"));
7423 }
7424 version__ = map_.next_value()?;
7425 }
7426 }
7427 }
7428 Ok(CreateSubscriptionResponse {
7429 status: status__,
7430 version: version__,
7431 })
7432 }
7433 }
7434 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
7435 }
7436}
7437impl serde::Serialize for CreateTableRequest {
7438 #[allow(deprecated)]
7439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7440 where
7441 S: serde::Serializer,
7442 {
7443 use serde::ser::SerializeStruct;
7444 let mut len = 0;
7445 if self.source.is_some() {
7446 len += 1;
7447 }
7448 if self.materialized_view.is_some() {
7449 len += 1;
7450 }
7451 if self.fragment_graph.is_some() {
7452 len += 1;
7453 }
7454 if self.job_type != 0 {
7455 len += 1;
7456 }
7457 if self.if_not_exists {
7458 len += 1;
7459 }
7460 if !self.dependencies.is_empty() {
7461 len += 1;
7462 }
7463 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
7464 if let Some(v) = self.source.as_ref() {
7465 struct_ser.serialize_field("source", v)?;
7466 }
7467 if let Some(v) = self.materialized_view.as_ref() {
7468 struct_ser.serialize_field("materializedView", v)?;
7469 }
7470 if let Some(v) = self.fragment_graph.as_ref() {
7471 struct_ser.serialize_field("fragmentGraph", v)?;
7472 }
7473 if self.job_type != 0 {
7474 let v = TableJobType::try_from(self.job_type)
7475 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
7476 struct_ser.serialize_field("jobType", &v)?;
7477 }
7478 if self.if_not_exists {
7479 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
7480 }
7481 if !self.dependencies.is_empty() {
7482 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7483 }
7484 struct_ser.end()
7485 }
7486}
7487impl<'de> serde::Deserialize<'de> for CreateTableRequest {
7488 #[allow(deprecated)]
7489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7490 where
7491 D: serde::Deserializer<'de>,
7492 {
7493 const FIELDS: &[&str] = &[
7494 "source",
7495 "materialized_view",
7496 "materializedView",
7497 "fragment_graph",
7498 "fragmentGraph",
7499 "job_type",
7500 "jobType",
7501 "if_not_exists",
7502 "ifNotExists",
7503 "dependencies",
7504 ];
7505
7506 #[allow(clippy::enum_variant_names)]
7507 enum GeneratedField {
7508 Source,
7509 MaterializedView,
7510 FragmentGraph,
7511 JobType,
7512 IfNotExists,
7513 Dependencies,
7514 }
7515 impl<'de> serde::Deserialize<'de> for GeneratedField {
7516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7517 where
7518 D: serde::Deserializer<'de>,
7519 {
7520 struct GeneratedVisitor;
7521
7522 impl serde::de::Visitor<'_> for GeneratedVisitor {
7523 type Value = GeneratedField;
7524
7525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7526 write!(formatter, "expected one of: {:?}", &FIELDS)
7527 }
7528
7529 #[allow(unused_variables)]
7530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7531 where
7532 E: serde::de::Error,
7533 {
7534 match value {
7535 "source" => Ok(GeneratedField::Source),
7536 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
7537 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
7538 "jobType" | "job_type" => Ok(GeneratedField::JobType),
7539 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
7540 "dependencies" => Ok(GeneratedField::Dependencies),
7541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7542 }
7543 }
7544 }
7545 deserializer.deserialize_identifier(GeneratedVisitor)
7546 }
7547 }
7548 struct GeneratedVisitor;
7549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7550 type Value = CreateTableRequest;
7551
7552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7553 formatter.write_str("struct ddl_service.CreateTableRequest")
7554 }
7555
7556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
7557 where
7558 V: serde::de::MapAccess<'de>,
7559 {
7560 let mut source__ = None;
7561 let mut materialized_view__ = None;
7562 let mut fragment_graph__ = None;
7563 let mut job_type__ = None;
7564 let mut if_not_exists__ = None;
7565 let mut dependencies__ = None;
7566 while let Some(k) = map_.next_key()? {
7567 match k {
7568 GeneratedField::Source => {
7569 if source__.is_some() {
7570 return Err(serde::de::Error::duplicate_field("source"));
7571 }
7572 source__ = map_.next_value()?;
7573 }
7574 GeneratedField::MaterializedView => {
7575 if materialized_view__.is_some() {
7576 return Err(serde::de::Error::duplicate_field("materializedView"));
7577 }
7578 materialized_view__ = map_.next_value()?;
7579 }
7580 GeneratedField::FragmentGraph => {
7581 if fragment_graph__.is_some() {
7582 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
7583 }
7584 fragment_graph__ = map_.next_value()?;
7585 }
7586 GeneratedField::JobType => {
7587 if job_type__.is_some() {
7588 return Err(serde::de::Error::duplicate_field("jobType"));
7589 }
7590 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
7591 }
7592 GeneratedField::IfNotExists => {
7593 if if_not_exists__.is_some() {
7594 return Err(serde::de::Error::duplicate_field("ifNotExists"));
7595 }
7596 if_not_exists__ = Some(map_.next_value()?);
7597 }
7598 GeneratedField::Dependencies => {
7599 if dependencies__.is_some() {
7600 return Err(serde::de::Error::duplicate_field("dependencies"));
7601 }
7602 dependencies__ =
7603 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7604 .into_iter().map(|x| x.0).collect())
7605 ;
7606 }
7607 }
7608 }
7609 Ok(CreateTableRequest {
7610 source: source__,
7611 materialized_view: materialized_view__,
7612 fragment_graph: fragment_graph__,
7613 job_type: job_type__.unwrap_or_default(),
7614 if_not_exists: if_not_exists__.unwrap_or_default(),
7615 dependencies: dependencies__.unwrap_or_default(),
7616 })
7617 }
7618 }
7619 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
7620 }
7621}
7622impl serde::Serialize for CreateTableResponse {
7623 #[allow(deprecated)]
7624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7625 where
7626 S: serde::Serializer,
7627 {
7628 use serde::ser::SerializeStruct;
7629 let mut len = 0;
7630 if self.status.is_some() {
7631 len += 1;
7632 }
7633 if self.version.is_some() {
7634 len += 1;
7635 }
7636 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
7637 if let Some(v) = self.status.as_ref() {
7638 struct_ser.serialize_field("status", v)?;
7639 }
7640 if let Some(v) = self.version.as_ref() {
7641 struct_ser.serialize_field("version", v)?;
7642 }
7643 struct_ser.end()
7644 }
7645}
7646impl<'de> serde::Deserialize<'de> for CreateTableResponse {
7647 #[allow(deprecated)]
7648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7649 where
7650 D: serde::Deserializer<'de>,
7651 {
7652 const FIELDS: &[&str] = &[
7653 "status",
7654 "version",
7655 ];
7656
7657 #[allow(clippy::enum_variant_names)]
7658 enum GeneratedField {
7659 Status,
7660 Version,
7661 }
7662 impl<'de> serde::Deserialize<'de> for GeneratedField {
7663 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7664 where
7665 D: serde::Deserializer<'de>,
7666 {
7667 struct GeneratedVisitor;
7668
7669 impl serde::de::Visitor<'_> for GeneratedVisitor {
7670 type Value = GeneratedField;
7671
7672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7673 write!(formatter, "expected one of: {:?}", &FIELDS)
7674 }
7675
7676 #[allow(unused_variables)]
7677 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7678 where
7679 E: serde::de::Error,
7680 {
7681 match value {
7682 "status" => Ok(GeneratedField::Status),
7683 "version" => Ok(GeneratedField::Version),
7684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7685 }
7686 }
7687 }
7688 deserializer.deserialize_identifier(GeneratedVisitor)
7689 }
7690 }
7691 struct GeneratedVisitor;
7692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7693 type Value = CreateTableResponse;
7694
7695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7696 formatter.write_str("struct ddl_service.CreateTableResponse")
7697 }
7698
7699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
7700 where
7701 V: serde::de::MapAccess<'de>,
7702 {
7703 let mut status__ = None;
7704 let mut version__ = None;
7705 while let Some(k) = map_.next_key()? {
7706 match k {
7707 GeneratedField::Status => {
7708 if status__.is_some() {
7709 return Err(serde::de::Error::duplicate_field("status"));
7710 }
7711 status__ = map_.next_value()?;
7712 }
7713 GeneratedField::Version => {
7714 if version__.is_some() {
7715 return Err(serde::de::Error::duplicate_field("version"));
7716 }
7717 version__ = map_.next_value()?;
7718 }
7719 }
7720 }
7721 Ok(CreateTableResponse {
7722 status: status__,
7723 version: version__,
7724 })
7725 }
7726 }
7727 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
7728 }
7729}
7730impl serde::Serialize for CreateViewRequest {
7731 #[allow(deprecated)]
7732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7733 where
7734 S: serde::Serializer,
7735 {
7736 use serde::ser::SerializeStruct;
7737 let mut len = 0;
7738 if self.view.is_some() {
7739 len += 1;
7740 }
7741 if !self.dependencies.is_empty() {
7742 len += 1;
7743 }
7744 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
7745 if let Some(v) = self.view.as_ref() {
7746 struct_ser.serialize_field("view", v)?;
7747 }
7748 if !self.dependencies.is_empty() {
7749 struct_ser.serialize_field("dependencies", &self.dependencies)?;
7750 }
7751 struct_ser.end()
7752 }
7753}
7754impl<'de> serde::Deserialize<'de> for CreateViewRequest {
7755 #[allow(deprecated)]
7756 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7757 where
7758 D: serde::Deserializer<'de>,
7759 {
7760 const FIELDS: &[&str] = &[
7761 "view",
7762 "dependencies",
7763 ];
7764
7765 #[allow(clippy::enum_variant_names)]
7766 enum GeneratedField {
7767 View,
7768 Dependencies,
7769 }
7770 impl<'de> serde::Deserialize<'de> for GeneratedField {
7771 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7772 where
7773 D: serde::Deserializer<'de>,
7774 {
7775 struct GeneratedVisitor;
7776
7777 impl serde::de::Visitor<'_> for GeneratedVisitor {
7778 type Value = GeneratedField;
7779
7780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7781 write!(formatter, "expected one of: {:?}", &FIELDS)
7782 }
7783
7784 #[allow(unused_variables)]
7785 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7786 where
7787 E: serde::de::Error,
7788 {
7789 match value {
7790 "view" => Ok(GeneratedField::View),
7791 "dependencies" => Ok(GeneratedField::Dependencies),
7792 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7793 }
7794 }
7795 }
7796 deserializer.deserialize_identifier(GeneratedVisitor)
7797 }
7798 }
7799 struct GeneratedVisitor;
7800 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7801 type Value = CreateViewRequest;
7802
7803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7804 formatter.write_str("struct ddl_service.CreateViewRequest")
7805 }
7806
7807 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7808 where
7809 V: serde::de::MapAccess<'de>,
7810 {
7811 let mut view__ = None;
7812 let mut dependencies__ = None;
7813 while let Some(k) = map_.next_key()? {
7814 match k {
7815 GeneratedField::View => {
7816 if view__.is_some() {
7817 return Err(serde::de::Error::duplicate_field("view"));
7818 }
7819 view__ = map_.next_value()?;
7820 }
7821 GeneratedField::Dependencies => {
7822 if dependencies__.is_some() {
7823 return Err(serde::de::Error::duplicate_field("dependencies"));
7824 }
7825 dependencies__ =
7826 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7827 .into_iter().map(|x| x.0).collect())
7828 ;
7829 }
7830 }
7831 }
7832 Ok(CreateViewRequest {
7833 view: view__,
7834 dependencies: dependencies__.unwrap_or_default(),
7835 })
7836 }
7837 }
7838 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7839 }
7840}
7841impl serde::Serialize for CreateViewResponse {
7842 #[allow(deprecated)]
7843 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7844 where
7845 S: serde::Serializer,
7846 {
7847 use serde::ser::SerializeStruct;
7848 let mut len = 0;
7849 if self.status.is_some() {
7850 len += 1;
7851 }
7852 if self.version.is_some() {
7853 len += 1;
7854 }
7855 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7856 if let Some(v) = self.status.as_ref() {
7857 struct_ser.serialize_field("status", v)?;
7858 }
7859 if let Some(v) = self.version.as_ref() {
7860 struct_ser.serialize_field("version", v)?;
7861 }
7862 struct_ser.end()
7863 }
7864}
7865impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7866 #[allow(deprecated)]
7867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7868 where
7869 D: serde::Deserializer<'de>,
7870 {
7871 const FIELDS: &[&str] = &[
7872 "status",
7873 "version",
7874 ];
7875
7876 #[allow(clippy::enum_variant_names)]
7877 enum GeneratedField {
7878 Status,
7879 Version,
7880 }
7881 impl<'de> serde::Deserialize<'de> for GeneratedField {
7882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7883 where
7884 D: serde::Deserializer<'de>,
7885 {
7886 struct GeneratedVisitor;
7887
7888 impl serde::de::Visitor<'_> for GeneratedVisitor {
7889 type Value = GeneratedField;
7890
7891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7892 write!(formatter, "expected one of: {:?}", &FIELDS)
7893 }
7894
7895 #[allow(unused_variables)]
7896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7897 where
7898 E: serde::de::Error,
7899 {
7900 match value {
7901 "status" => Ok(GeneratedField::Status),
7902 "version" => Ok(GeneratedField::Version),
7903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7904 }
7905 }
7906 }
7907 deserializer.deserialize_identifier(GeneratedVisitor)
7908 }
7909 }
7910 struct GeneratedVisitor;
7911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7912 type Value = CreateViewResponse;
7913
7914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7915 formatter.write_str("struct ddl_service.CreateViewResponse")
7916 }
7917
7918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7919 where
7920 V: serde::de::MapAccess<'de>,
7921 {
7922 let mut status__ = None;
7923 let mut version__ = None;
7924 while let Some(k) = map_.next_key()? {
7925 match k {
7926 GeneratedField::Status => {
7927 if status__.is_some() {
7928 return Err(serde::de::Error::duplicate_field("status"));
7929 }
7930 status__ = map_.next_value()?;
7931 }
7932 GeneratedField::Version => {
7933 if version__.is_some() {
7934 return Err(serde::de::Error::duplicate_field("version"));
7935 }
7936 version__ = map_.next_value()?;
7937 }
7938 }
7939 }
7940 Ok(CreateViewResponse {
7941 status: status__,
7942 version: version__,
7943 })
7944 }
7945 }
7946 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7947 }
7948}
7949impl serde::Serialize for DdlProgress {
7950 #[allow(deprecated)]
7951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7952 where
7953 S: serde::Serializer,
7954 {
7955 use serde::ser::SerializeStruct;
7956 let mut len = 0;
7957 if self.id != 0 {
7958 len += 1;
7959 }
7960 if !self.statement.is_empty() {
7961 len += 1;
7962 }
7963 if !self.progress.is_empty() {
7964 len += 1;
7965 }
7966 if !self.create_type.is_empty() {
7967 len += 1;
7968 }
7969 if self.initialized_at_time_millis != 0 {
7970 len += 1;
7971 }
7972 if self.is_serverless_backfill {
7973 len += 1;
7974 }
7975 if self.backfill_type != 0 {
7976 len += 1;
7977 }
7978 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
7979 if self.id != 0 {
7980 #[allow(clippy::needless_borrow)]
7981 #[allow(clippy::needless_borrows_for_generic_args)]
7982 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7983 }
7984 if !self.statement.is_empty() {
7985 struct_ser.serialize_field("statement", &self.statement)?;
7986 }
7987 if !self.progress.is_empty() {
7988 struct_ser.serialize_field("progress", &self.progress)?;
7989 }
7990 if !self.create_type.is_empty() {
7991 struct_ser.serialize_field("createType", &self.create_type)?;
7992 }
7993 if self.initialized_at_time_millis != 0 {
7994 #[allow(clippy::needless_borrow)]
7995 #[allow(clippy::needless_borrows_for_generic_args)]
7996 struct_ser.serialize_field("initializedAtTimeMillis", ToString::to_string(&self.initialized_at_time_millis).as_str())?;
7997 }
7998 if self.is_serverless_backfill {
7999 struct_ser.serialize_field("isServerlessBackfill", &self.is_serverless_backfill)?;
8000 }
8001 if self.backfill_type != 0 {
8002 let v = BackfillType::try_from(self.backfill_type)
8003 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill_type)))?;
8004 struct_ser.serialize_field("backfillType", &v)?;
8005 }
8006 struct_ser.end()
8007 }
8008}
8009impl<'de> serde::Deserialize<'de> for DdlProgress {
8010 #[allow(deprecated)]
8011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8012 where
8013 D: serde::Deserializer<'de>,
8014 {
8015 const FIELDS: &[&str] = &[
8016 "id",
8017 "statement",
8018 "progress",
8019 "create_type",
8020 "createType",
8021 "initialized_at_time_millis",
8022 "initializedAtTimeMillis",
8023 "is_serverless_backfill",
8024 "isServerlessBackfill",
8025 "backfill_type",
8026 "backfillType",
8027 ];
8028
8029 #[allow(clippy::enum_variant_names)]
8030 enum GeneratedField {
8031 Id,
8032 Statement,
8033 Progress,
8034 CreateType,
8035 InitializedAtTimeMillis,
8036 IsServerlessBackfill,
8037 BackfillType,
8038 }
8039 impl<'de> serde::Deserialize<'de> for GeneratedField {
8040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8041 where
8042 D: serde::Deserializer<'de>,
8043 {
8044 struct GeneratedVisitor;
8045
8046 impl serde::de::Visitor<'_> for GeneratedVisitor {
8047 type Value = GeneratedField;
8048
8049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8050 write!(formatter, "expected one of: {:?}", &FIELDS)
8051 }
8052
8053 #[allow(unused_variables)]
8054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8055 where
8056 E: serde::de::Error,
8057 {
8058 match value {
8059 "id" => Ok(GeneratedField::Id),
8060 "statement" => Ok(GeneratedField::Statement),
8061 "progress" => Ok(GeneratedField::Progress),
8062 "createType" | "create_type" => Ok(GeneratedField::CreateType),
8063 "initializedAtTimeMillis" | "initialized_at_time_millis" => Ok(GeneratedField::InitializedAtTimeMillis),
8064 "isServerlessBackfill" | "is_serverless_backfill" => Ok(GeneratedField::IsServerlessBackfill),
8065 "backfillType" | "backfill_type" => Ok(GeneratedField::BackfillType),
8066 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8067 }
8068 }
8069 }
8070 deserializer.deserialize_identifier(GeneratedVisitor)
8071 }
8072 }
8073 struct GeneratedVisitor;
8074 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8075 type Value = DdlProgress;
8076
8077 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8078 formatter.write_str("struct ddl_service.DdlProgress")
8079 }
8080
8081 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
8082 where
8083 V: serde::de::MapAccess<'de>,
8084 {
8085 let mut id__ = None;
8086 let mut statement__ = None;
8087 let mut progress__ = None;
8088 let mut create_type__ = None;
8089 let mut initialized_at_time_millis__ = None;
8090 let mut is_serverless_backfill__ = None;
8091 let mut backfill_type__ = None;
8092 while let Some(k) = map_.next_key()? {
8093 match k {
8094 GeneratedField::Id => {
8095 if id__.is_some() {
8096 return Err(serde::de::Error::duplicate_field("id"));
8097 }
8098 id__ =
8099 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8100 ;
8101 }
8102 GeneratedField::Statement => {
8103 if statement__.is_some() {
8104 return Err(serde::de::Error::duplicate_field("statement"));
8105 }
8106 statement__ = Some(map_.next_value()?);
8107 }
8108 GeneratedField::Progress => {
8109 if progress__.is_some() {
8110 return Err(serde::de::Error::duplicate_field("progress"));
8111 }
8112 progress__ = Some(map_.next_value()?);
8113 }
8114 GeneratedField::CreateType => {
8115 if create_type__.is_some() {
8116 return Err(serde::de::Error::duplicate_field("createType"));
8117 }
8118 create_type__ = Some(map_.next_value()?);
8119 }
8120 GeneratedField::InitializedAtTimeMillis => {
8121 if initialized_at_time_millis__.is_some() {
8122 return Err(serde::de::Error::duplicate_field("initializedAtTimeMillis"));
8123 }
8124 initialized_at_time_millis__ =
8125 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8126 ;
8127 }
8128 GeneratedField::IsServerlessBackfill => {
8129 if is_serverless_backfill__.is_some() {
8130 return Err(serde::de::Error::duplicate_field("isServerlessBackfill"));
8131 }
8132 is_serverless_backfill__ = Some(map_.next_value()?);
8133 }
8134 GeneratedField::BackfillType => {
8135 if backfill_type__.is_some() {
8136 return Err(serde::de::Error::duplicate_field("backfillType"));
8137 }
8138 backfill_type__ = Some(map_.next_value::<BackfillType>()? as i32);
8139 }
8140 }
8141 }
8142 Ok(DdlProgress {
8143 id: id__.unwrap_or_default(),
8144 statement: statement__.unwrap_or_default(),
8145 progress: progress__.unwrap_or_default(),
8146 create_type: create_type__.unwrap_or_default(),
8147 initialized_at_time_millis: initialized_at_time_millis__.unwrap_or_default(),
8148 is_serverless_backfill: is_serverless_backfill__.unwrap_or_default(),
8149 backfill_type: backfill_type__.unwrap_or_default(),
8150 })
8151 }
8152 }
8153 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
8154 }
8155}
8156impl serde::Serialize for DropConnectionRequest {
8157 #[allow(deprecated)]
8158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8159 where
8160 S: serde::Serializer,
8161 {
8162 use serde::ser::SerializeStruct;
8163 let mut len = 0;
8164 if self.connection_id != 0 {
8165 len += 1;
8166 }
8167 if self.cascade {
8168 len += 1;
8169 }
8170 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
8171 if self.connection_id != 0 {
8172 struct_ser.serialize_field("connectionId", &self.connection_id)?;
8173 }
8174 if self.cascade {
8175 struct_ser.serialize_field("cascade", &self.cascade)?;
8176 }
8177 struct_ser.end()
8178 }
8179}
8180impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
8181 #[allow(deprecated)]
8182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8183 where
8184 D: serde::Deserializer<'de>,
8185 {
8186 const FIELDS: &[&str] = &[
8187 "connection_id",
8188 "connectionId",
8189 "cascade",
8190 ];
8191
8192 #[allow(clippy::enum_variant_names)]
8193 enum GeneratedField {
8194 ConnectionId,
8195 Cascade,
8196 }
8197 impl<'de> serde::Deserialize<'de> for GeneratedField {
8198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8199 where
8200 D: serde::Deserializer<'de>,
8201 {
8202 struct GeneratedVisitor;
8203
8204 impl serde::de::Visitor<'_> for GeneratedVisitor {
8205 type Value = GeneratedField;
8206
8207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8208 write!(formatter, "expected one of: {:?}", &FIELDS)
8209 }
8210
8211 #[allow(unused_variables)]
8212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8213 where
8214 E: serde::de::Error,
8215 {
8216 match value {
8217 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
8218 "cascade" => Ok(GeneratedField::Cascade),
8219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8220 }
8221 }
8222 }
8223 deserializer.deserialize_identifier(GeneratedVisitor)
8224 }
8225 }
8226 struct GeneratedVisitor;
8227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8228 type Value = DropConnectionRequest;
8229
8230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8231 formatter.write_str("struct ddl_service.DropConnectionRequest")
8232 }
8233
8234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
8235 where
8236 V: serde::de::MapAccess<'de>,
8237 {
8238 let mut connection_id__ = None;
8239 let mut cascade__ = None;
8240 while let Some(k) = map_.next_key()? {
8241 match k {
8242 GeneratedField::ConnectionId => {
8243 if connection_id__.is_some() {
8244 return Err(serde::de::Error::duplicate_field("connectionId"));
8245 }
8246 connection_id__ =
8247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8248 ;
8249 }
8250 GeneratedField::Cascade => {
8251 if cascade__.is_some() {
8252 return Err(serde::de::Error::duplicate_field("cascade"));
8253 }
8254 cascade__ = Some(map_.next_value()?);
8255 }
8256 }
8257 }
8258 Ok(DropConnectionRequest {
8259 connection_id: connection_id__.unwrap_or_default(),
8260 cascade: cascade__.unwrap_or_default(),
8261 })
8262 }
8263 }
8264 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
8265 }
8266}
8267impl serde::Serialize for DropConnectionResponse {
8268 #[allow(deprecated)]
8269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8270 where
8271 S: serde::Serializer,
8272 {
8273 use serde::ser::SerializeStruct;
8274 let mut len = 0;
8275 if self.status.is_some() {
8276 len += 1;
8277 }
8278 if self.version.is_some() {
8279 len += 1;
8280 }
8281 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
8282 if let Some(v) = self.status.as_ref() {
8283 struct_ser.serialize_field("status", v)?;
8284 }
8285 if let Some(v) = self.version.as_ref() {
8286 struct_ser.serialize_field("version", v)?;
8287 }
8288 struct_ser.end()
8289 }
8290}
8291impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
8292 #[allow(deprecated)]
8293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8294 where
8295 D: serde::Deserializer<'de>,
8296 {
8297 const FIELDS: &[&str] = &[
8298 "status",
8299 "version",
8300 ];
8301
8302 #[allow(clippy::enum_variant_names)]
8303 enum GeneratedField {
8304 Status,
8305 Version,
8306 }
8307 impl<'de> serde::Deserialize<'de> for GeneratedField {
8308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8309 where
8310 D: serde::Deserializer<'de>,
8311 {
8312 struct GeneratedVisitor;
8313
8314 impl serde::de::Visitor<'_> for GeneratedVisitor {
8315 type Value = GeneratedField;
8316
8317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8318 write!(formatter, "expected one of: {:?}", &FIELDS)
8319 }
8320
8321 #[allow(unused_variables)]
8322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8323 where
8324 E: serde::de::Error,
8325 {
8326 match value {
8327 "status" => Ok(GeneratedField::Status),
8328 "version" => Ok(GeneratedField::Version),
8329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8330 }
8331 }
8332 }
8333 deserializer.deserialize_identifier(GeneratedVisitor)
8334 }
8335 }
8336 struct GeneratedVisitor;
8337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8338 type Value = DropConnectionResponse;
8339
8340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8341 formatter.write_str("struct ddl_service.DropConnectionResponse")
8342 }
8343
8344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
8345 where
8346 V: serde::de::MapAccess<'de>,
8347 {
8348 let mut status__ = None;
8349 let mut version__ = None;
8350 while let Some(k) = map_.next_key()? {
8351 match k {
8352 GeneratedField::Status => {
8353 if status__.is_some() {
8354 return Err(serde::de::Error::duplicate_field("status"));
8355 }
8356 status__ = map_.next_value()?;
8357 }
8358 GeneratedField::Version => {
8359 if version__.is_some() {
8360 return Err(serde::de::Error::duplicate_field("version"));
8361 }
8362 version__ = map_.next_value()?;
8363 }
8364 }
8365 }
8366 Ok(DropConnectionResponse {
8367 status: status__,
8368 version: version__,
8369 })
8370 }
8371 }
8372 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
8373 }
8374}
8375impl serde::Serialize for DropDatabaseRequest {
8376 #[allow(deprecated)]
8377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8378 where
8379 S: serde::Serializer,
8380 {
8381 use serde::ser::SerializeStruct;
8382 let mut len = 0;
8383 if self.database_id != 0 {
8384 len += 1;
8385 }
8386 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
8387 if self.database_id != 0 {
8388 struct_ser.serialize_field("databaseId", &self.database_id)?;
8389 }
8390 struct_ser.end()
8391 }
8392}
8393impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
8394 #[allow(deprecated)]
8395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8396 where
8397 D: serde::Deserializer<'de>,
8398 {
8399 const FIELDS: &[&str] = &[
8400 "database_id",
8401 "databaseId",
8402 ];
8403
8404 #[allow(clippy::enum_variant_names)]
8405 enum GeneratedField {
8406 DatabaseId,
8407 }
8408 impl<'de> serde::Deserialize<'de> for GeneratedField {
8409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8410 where
8411 D: serde::Deserializer<'de>,
8412 {
8413 struct GeneratedVisitor;
8414
8415 impl serde::de::Visitor<'_> for GeneratedVisitor {
8416 type Value = GeneratedField;
8417
8418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8419 write!(formatter, "expected one of: {:?}", &FIELDS)
8420 }
8421
8422 #[allow(unused_variables)]
8423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8424 where
8425 E: serde::de::Error,
8426 {
8427 match value {
8428 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
8429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8430 }
8431 }
8432 }
8433 deserializer.deserialize_identifier(GeneratedVisitor)
8434 }
8435 }
8436 struct GeneratedVisitor;
8437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8438 type Value = DropDatabaseRequest;
8439
8440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8441 formatter.write_str("struct ddl_service.DropDatabaseRequest")
8442 }
8443
8444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
8445 where
8446 V: serde::de::MapAccess<'de>,
8447 {
8448 let mut database_id__ = None;
8449 while let Some(k) = map_.next_key()? {
8450 match k {
8451 GeneratedField::DatabaseId => {
8452 if database_id__.is_some() {
8453 return Err(serde::de::Error::duplicate_field("databaseId"));
8454 }
8455 database_id__ =
8456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8457 ;
8458 }
8459 }
8460 }
8461 Ok(DropDatabaseRequest {
8462 database_id: database_id__.unwrap_or_default(),
8463 })
8464 }
8465 }
8466 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
8467 }
8468}
8469impl serde::Serialize for DropDatabaseResponse {
8470 #[allow(deprecated)]
8471 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8472 where
8473 S: serde::Serializer,
8474 {
8475 use serde::ser::SerializeStruct;
8476 let mut len = 0;
8477 if self.status.is_some() {
8478 len += 1;
8479 }
8480 if self.version.is_some() {
8481 len += 1;
8482 }
8483 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
8484 if let Some(v) = self.status.as_ref() {
8485 struct_ser.serialize_field("status", v)?;
8486 }
8487 if let Some(v) = self.version.as_ref() {
8488 struct_ser.serialize_field("version", v)?;
8489 }
8490 struct_ser.end()
8491 }
8492}
8493impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
8494 #[allow(deprecated)]
8495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8496 where
8497 D: serde::Deserializer<'de>,
8498 {
8499 const FIELDS: &[&str] = &[
8500 "status",
8501 "version",
8502 ];
8503
8504 #[allow(clippy::enum_variant_names)]
8505 enum GeneratedField {
8506 Status,
8507 Version,
8508 }
8509 impl<'de> serde::Deserialize<'de> for GeneratedField {
8510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8511 where
8512 D: serde::Deserializer<'de>,
8513 {
8514 struct GeneratedVisitor;
8515
8516 impl serde::de::Visitor<'_> for GeneratedVisitor {
8517 type Value = GeneratedField;
8518
8519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8520 write!(formatter, "expected one of: {:?}", &FIELDS)
8521 }
8522
8523 #[allow(unused_variables)]
8524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8525 where
8526 E: serde::de::Error,
8527 {
8528 match value {
8529 "status" => Ok(GeneratedField::Status),
8530 "version" => Ok(GeneratedField::Version),
8531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8532 }
8533 }
8534 }
8535 deserializer.deserialize_identifier(GeneratedVisitor)
8536 }
8537 }
8538 struct GeneratedVisitor;
8539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8540 type Value = DropDatabaseResponse;
8541
8542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8543 formatter.write_str("struct ddl_service.DropDatabaseResponse")
8544 }
8545
8546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
8547 where
8548 V: serde::de::MapAccess<'de>,
8549 {
8550 let mut status__ = None;
8551 let mut version__ = None;
8552 while let Some(k) = map_.next_key()? {
8553 match k {
8554 GeneratedField::Status => {
8555 if status__.is_some() {
8556 return Err(serde::de::Error::duplicate_field("status"));
8557 }
8558 status__ = map_.next_value()?;
8559 }
8560 GeneratedField::Version => {
8561 if version__.is_some() {
8562 return Err(serde::de::Error::duplicate_field("version"));
8563 }
8564 version__ = map_.next_value()?;
8565 }
8566 }
8567 }
8568 Ok(DropDatabaseResponse {
8569 status: status__,
8570 version: version__,
8571 })
8572 }
8573 }
8574 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
8575 }
8576}
8577impl serde::Serialize for DropFunctionRequest {
8578 #[allow(deprecated)]
8579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8580 where
8581 S: serde::Serializer,
8582 {
8583 use serde::ser::SerializeStruct;
8584 let mut len = 0;
8585 if self.function_id != 0 {
8586 len += 1;
8587 }
8588 if self.cascade {
8589 len += 1;
8590 }
8591 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
8592 if self.function_id != 0 {
8593 struct_ser.serialize_field("functionId", &self.function_id)?;
8594 }
8595 if self.cascade {
8596 struct_ser.serialize_field("cascade", &self.cascade)?;
8597 }
8598 struct_ser.end()
8599 }
8600}
8601impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
8602 #[allow(deprecated)]
8603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8604 where
8605 D: serde::Deserializer<'de>,
8606 {
8607 const FIELDS: &[&str] = &[
8608 "function_id",
8609 "functionId",
8610 "cascade",
8611 ];
8612
8613 #[allow(clippy::enum_variant_names)]
8614 enum GeneratedField {
8615 FunctionId,
8616 Cascade,
8617 }
8618 impl<'de> serde::Deserialize<'de> for GeneratedField {
8619 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8620 where
8621 D: serde::Deserializer<'de>,
8622 {
8623 struct GeneratedVisitor;
8624
8625 impl serde::de::Visitor<'_> for GeneratedVisitor {
8626 type Value = GeneratedField;
8627
8628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8629 write!(formatter, "expected one of: {:?}", &FIELDS)
8630 }
8631
8632 #[allow(unused_variables)]
8633 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8634 where
8635 E: serde::de::Error,
8636 {
8637 match value {
8638 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
8639 "cascade" => Ok(GeneratedField::Cascade),
8640 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8641 }
8642 }
8643 }
8644 deserializer.deserialize_identifier(GeneratedVisitor)
8645 }
8646 }
8647 struct GeneratedVisitor;
8648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8649 type Value = DropFunctionRequest;
8650
8651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8652 formatter.write_str("struct ddl_service.DropFunctionRequest")
8653 }
8654
8655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
8656 where
8657 V: serde::de::MapAccess<'de>,
8658 {
8659 let mut function_id__ = None;
8660 let mut cascade__ = None;
8661 while let Some(k) = map_.next_key()? {
8662 match k {
8663 GeneratedField::FunctionId => {
8664 if function_id__.is_some() {
8665 return Err(serde::de::Error::duplicate_field("functionId"));
8666 }
8667 function_id__ =
8668 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8669 ;
8670 }
8671 GeneratedField::Cascade => {
8672 if cascade__.is_some() {
8673 return Err(serde::de::Error::duplicate_field("cascade"));
8674 }
8675 cascade__ = Some(map_.next_value()?);
8676 }
8677 }
8678 }
8679 Ok(DropFunctionRequest {
8680 function_id: function_id__.unwrap_or_default(),
8681 cascade: cascade__.unwrap_or_default(),
8682 })
8683 }
8684 }
8685 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
8686 }
8687}
8688impl serde::Serialize for DropFunctionResponse {
8689 #[allow(deprecated)]
8690 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8691 where
8692 S: serde::Serializer,
8693 {
8694 use serde::ser::SerializeStruct;
8695 let mut len = 0;
8696 if self.status.is_some() {
8697 len += 1;
8698 }
8699 if self.version.is_some() {
8700 len += 1;
8701 }
8702 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
8703 if let Some(v) = self.status.as_ref() {
8704 struct_ser.serialize_field("status", v)?;
8705 }
8706 if let Some(v) = self.version.as_ref() {
8707 struct_ser.serialize_field("version", v)?;
8708 }
8709 struct_ser.end()
8710 }
8711}
8712impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
8713 #[allow(deprecated)]
8714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8715 where
8716 D: serde::Deserializer<'de>,
8717 {
8718 const FIELDS: &[&str] = &[
8719 "status",
8720 "version",
8721 ];
8722
8723 #[allow(clippy::enum_variant_names)]
8724 enum GeneratedField {
8725 Status,
8726 Version,
8727 }
8728 impl<'de> serde::Deserialize<'de> for GeneratedField {
8729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8730 where
8731 D: serde::Deserializer<'de>,
8732 {
8733 struct GeneratedVisitor;
8734
8735 impl serde::de::Visitor<'_> for GeneratedVisitor {
8736 type Value = GeneratedField;
8737
8738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8739 write!(formatter, "expected one of: {:?}", &FIELDS)
8740 }
8741
8742 #[allow(unused_variables)]
8743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8744 where
8745 E: serde::de::Error,
8746 {
8747 match value {
8748 "status" => Ok(GeneratedField::Status),
8749 "version" => Ok(GeneratedField::Version),
8750 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8751 }
8752 }
8753 }
8754 deserializer.deserialize_identifier(GeneratedVisitor)
8755 }
8756 }
8757 struct GeneratedVisitor;
8758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759 type Value = DropFunctionResponse;
8760
8761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762 formatter.write_str("struct ddl_service.DropFunctionResponse")
8763 }
8764
8765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
8766 where
8767 V: serde::de::MapAccess<'de>,
8768 {
8769 let mut status__ = None;
8770 let mut version__ = None;
8771 while let Some(k) = map_.next_key()? {
8772 match k {
8773 GeneratedField::Status => {
8774 if status__.is_some() {
8775 return Err(serde::de::Error::duplicate_field("status"));
8776 }
8777 status__ = map_.next_value()?;
8778 }
8779 GeneratedField::Version => {
8780 if version__.is_some() {
8781 return Err(serde::de::Error::duplicate_field("version"));
8782 }
8783 version__ = map_.next_value()?;
8784 }
8785 }
8786 }
8787 Ok(DropFunctionResponse {
8788 status: status__,
8789 version: version__,
8790 })
8791 }
8792 }
8793 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
8794 }
8795}
8796impl serde::Serialize for DropIndexRequest {
8797 #[allow(deprecated)]
8798 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8799 where
8800 S: serde::Serializer,
8801 {
8802 use serde::ser::SerializeStruct;
8803 let mut len = 0;
8804 if self.index_id != 0 {
8805 len += 1;
8806 }
8807 if self.cascade {
8808 len += 1;
8809 }
8810 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
8811 if self.index_id != 0 {
8812 struct_ser.serialize_field("indexId", &self.index_id)?;
8813 }
8814 if self.cascade {
8815 struct_ser.serialize_field("cascade", &self.cascade)?;
8816 }
8817 struct_ser.end()
8818 }
8819}
8820impl<'de> serde::Deserialize<'de> for DropIndexRequest {
8821 #[allow(deprecated)]
8822 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8823 where
8824 D: serde::Deserializer<'de>,
8825 {
8826 const FIELDS: &[&str] = &[
8827 "index_id",
8828 "indexId",
8829 "cascade",
8830 ];
8831
8832 #[allow(clippy::enum_variant_names)]
8833 enum GeneratedField {
8834 IndexId,
8835 Cascade,
8836 }
8837 impl<'de> serde::Deserialize<'de> for GeneratedField {
8838 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8839 where
8840 D: serde::Deserializer<'de>,
8841 {
8842 struct GeneratedVisitor;
8843
8844 impl serde::de::Visitor<'_> for GeneratedVisitor {
8845 type Value = GeneratedField;
8846
8847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8848 write!(formatter, "expected one of: {:?}", &FIELDS)
8849 }
8850
8851 #[allow(unused_variables)]
8852 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8853 where
8854 E: serde::de::Error,
8855 {
8856 match value {
8857 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8858 "cascade" => Ok(GeneratedField::Cascade),
8859 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8860 }
8861 }
8862 }
8863 deserializer.deserialize_identifier(GeneratedVisitor)
8864 }
8865 }
8866 struct GeneratedVisitor;
8867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8868 type Value = DropIndexRequest;
8869
8870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8871 formatter.write_str("struct ddl_service.DropIndexRequest")
8872 }
8873
8874 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8875 where
8876 V: serde::de::MapAccess<'de>,
8877 {
8878 let mut index_id__ = None;
8879 let mut cascade__ = None;
8880 while let Some(k) = map_.next_key()? {
8881 match k {
8882 GeneratedField::IndexId => {
8883 if index_id__.is_some() {
8884 return Err(serde::de::Error::duplicate_field("indexId"));
8885 }
8886 index_id__ =
8887 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8888 ;
8889 }
8890 GeneratedField::Cascade => {
8891 if cascade__.is_some() {
8892 return Err(serde::de::Error::duplicate_field("cascade"));
8893 }
8894 cascade__ = Some(map_.next_value()?);
8895 }
8896 }
8897 }
8898 Ok(DropIndexRequest {
8899 index_id: index_id__.unwrap_or_default(),
8900 cascade: cascade__.unwrap_or_default(),
8901 })
8902 }
8903 }
8904 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8905 }
8906}
8907impl serde::Serialize for DropIndexResponse {
8908 #[allow(deprecated)]
8909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8910 where
8911 S: serde::Serializer,
8912 {
8913 use serde::ser::SerializeStruct;
8914 let mut len = 0;
8915 if self.status.is_some() {
8916 len += 1;
8917 }
8918 if self.version.is_some() {
8919 len += 1;
8920 }
8921 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8922 if let Some(v) = self.status.as_ref() {
8923 struct_ser.serialize_field("status", v)?;
8924 }
8925 if let Some(v) = self.version.as_ref() {
8926 struct_ser.serialize_field("version", v)?;
8927 }
8928 struct_ser.end()
8929 }
8930}
8931impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8932 #[allow(deprecated)]
8933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8934 where
8935 D: serde::Deserializer<'de>,
8936 {
8937 const FIELDS: &[&str] = &[
8938 "status",
8939 "version",
8940 ];
8941
8942 #[allow(clippy::enum_variant_names)]
8943 enum GeneratedField {
8944 Status,
8945 Version,
8946 }
8947 impl<'de> serde::Deserialize<'de> for GeneratedField {
8948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8949 where
8950 D: serde::Deserializer<'de>,
8951 {
8952 struct GeneratedVisitor;
8953
8954 impl serde::de::Visitor<'_> for GeneratedVisitor {
8955 type Value = GeneratedField;
8956
8957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8958 write!(formatter, "expected one of: {:?}", &FIELDS)
8959 }
8960
8961 #[allow(unused_variables)]
8962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8963 where
8964 E: serde::de::Error,
8965 {
8966 match value {
8967 "status" => Ok(GeneratedField::Status),
8968 "version" => Ok(GeneratedField::Version),
8969 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8970 }
8971 }
8972 }
8973 deserializer.deserialize_identifier(GeneratedVisitor)
8974 }
8975 }
8976 struct GeneratedVisitor;
8977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8978 type Value = DropIndexResponse;
8979
8980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8981 formatter.write_str("struct ddl_service.DropIndexResponse")
8982 }
8983
8984 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
8985 where
8986 V: serde::de::MapAccess<'de>,
8987 {
8988 let mut status__ = None;
8989 let mut version__ = None;
8990 while let Some(k) = map_.next_key()? {
8991 match k {
8992 GeneratedField::Status => {
8993 if status__.is_some() {
8994 return Err(serde::de::Error::duplicate_field("status"));
8995 }
8996 status__ = map_.next_value()?;
8997 }
8998 GeneratedField::Version => {
8999 if version__.is_some() {
9000 return Err(serde::de::Error::duplicate_field("version"));
9001 }
9002 version__ = map_.next_value()?;
9003 }
9004 }
9005 }
9006 Ok(DropIndexResponse {
9007 status: status__,
9008 version: version__,
9009 })
9010 }
9011 }
9012 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
9013 }
9014}
9015impl serde::Serialize for DropMaterializedViewRequest {
9016 #[allow(deprecated)]
9017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9018 where
9019 S: serde::Serializer,
9020 {
9021 use serde::ser::SerializeStruct;
9022 let mut len = 0;
9023 if self.table_id != 0 {
9024 len += 1;
9025 }
9026 if self.cascade {
9027 len += 1;
9028 }
9029 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
9030 if self.table_id != 0 {
9031 struct_ser.serialize_field("tableId", &self.table_id)?;
9032 }
9033 if self.cascade {
9034 struct_ser.serialize_field("cascade", &self.cascade)?;
9035 }
9036 struct_ser.end()
9037 }
9038}
9039impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
9040 #[allow(deprecated)]
9041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9042 where
9043 D: serde::Deserializer<'de>,
9044 {
9045 const FIELDS: &[&str] = &[
9046 "table_id",
9047 "tableId",
9048 "cascade",
9049 ];
9050
9051 #[allow(clippy::enum_variant_names)]
9052 enum GeneratedField {
9053 TableId,
9054 Cascade,
9055 }
9056 impl<'de> serde::Deserialize<'de> for GeneratedField {
9057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9058 where
9059 D: serde::Deserializer<'de>,
9060 {
9061 struct GeneratedVisitor;
9062
9063 impl serde::de::Visitor<'_> for GeneratedVisitor {
9064 type Value = GeneratedField;
9065
9066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9067 write!(formatter, "expected one of: {:?}", &FIELDS)
9068 }
9069
9070 #[allow(unused_variables)]
9071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9072 where
9073 E: serde::de::Error,
9074 {
9075 match value {
9076 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9077 "cascade" => Ok(GeneratedField::Cascade),
9078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9079 }
9080 }
9081 }
9082 deserializer.deserialize_identifier(GeneratedVisitor)
9083 }
9084 }
9085 struct GeneratedVisitor;
9086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9087 type Value = DropMaterializedViewRequest;
9088
9089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9090 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
9091 }
9092
9093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
9094 where
9095 V: serde::de::MapAccess<'de>,
9096 {
9097 let mut table_id__ = None;
9098 let mut cascade__ = None;
9099 while let Some(k) = map_.next_key()? {
9100 match k {
9101 GeneratedField::TableId => {
9102 if table_id__.is_some() {
9103 return Err(serde::de::Error::duplicate_field("tableId"));
9104 }
9105 table_id__ =
9106 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9107 ;
9108 }
9109 GeneratedField::Cascade => {
9110 if cascade__.is_some() {
9111 return Err(serde::de::Error::duplicate_field("cascade"));
9112 }
9113 cascade__ = Some(map_.next_value()?);
9114 }
9115 }
9116 }
9117 Ok(DropMaterializedViewRequest {
9118 table_id: table_id__.unwrap_or_default(),
9119 cascade: cascade__.unwrap_or_default(),
9120 })
9121 }
9122 }
9123 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
9124 }
9125}
9126impl serde::Serialize for DropMaterializedViewResponse {
9127 #[allow(deprecated)]
9128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9129 where
9130 S: serde::Serializer,
9131 {
9132 use serde::ser::SerializeStruct;
9133 let mut len = 0;
9134 if self.status.is_some() {
9135 len += 1;
9136 }
9137 if self.version.is_some() {
9138 len += 1;
9139 }
9140 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
9141 if let Some(v) = self.status.as_ref() {
9142 struct_ser.serialize_field("status", v)?;
9143 }
9144 if let Some(v) = self.version.as_ref() {
9145 struct_ser.serialize_field("version", v)?;
9146 }
9147 struct_ser.end()
9148 }
9149}
9150impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
9151 #[allow(deprecated)]
9152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9153 where
9154 D: serde::Deserializer<'de>,
9155 {
9156 const FIELDS: &[&str] = &[
9157 "status",
9158 "version",
9159 ];
9160
9161 #[allow(clippy::enum_variant_names)]
9162 enum GeneratedField {
9163 Status,
9164 Version,
9165 }
9166 impl<'de> serde::Deserialize<'de> for GeneratedField {
9167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9168 where
9169 D: serde::Deserializer<'de>,
9170 {
9171 struct GeneratedVisitor;
9172
9173 impl serde::de::Visitor<'_> for GeneratedVisitor {
9174 type Value = GeneratedField;
9175
9176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9177 write!(formatter, "expected one of: {:?}", &FIELDS)
9178 }
9179
9180 #[allow(unused_variables)]
9181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9182 where
9183 E: serde::de::Error,
9184 {
9185 match value {
9186 "status" => Ok(GeneratedField::Status),
9187 "version" => Ok(GeneratedField::Version),
9188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9189 }
9190 }
9191 }
9192 deserializer.deserialize_identifier(GeneratedVisitor)
9193 }
9194 }
9195 struct GeneratedVisitor;
9196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9197 type Value = DropMaterializedViewResponse;
9198
9199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9200 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
9201 }
9202
9203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
9204 where
9205 V: serde::de::MapAccess<'de>,
9206 {
9207 let mut status__ = None;
9208 let mut version__ = None;
9209 while let Some(k) = map_.next_key()? {
9210 match k {
9211 GeneratedField::Status => {
9212 if status__.is_some() {
9213 return Err(serde::de::Error::duplicate_field("status"));
9214 }
9215 status__ = map_.next_value()?;
9216 }
9217 GeneratedField::Version => {
9218 if version__.is_some() {
9219 return Err(serde::de::Error::duplicate_field("version"));
9220 }
9221 version__ = map_.next_value()?;
9222 }
9223 }
9224 }
9225 Ok(DropMaterializedViewResponse {
9226 status: status__,
9227 version: version__,
9228 })
9229 }
9230 }
9231 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
9232 }
9233}
9234impl serde::Serialize for DropSchemaRequest {
9235 #[allow(deprecated)]
9236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9237 where
9238 S: serde::Serializer,
9239 {
9240 use serde::ser::SerializeStruct;
9241 let mut len = 0;
9242 if self.schema_id != 0 {
9243 len += 1;
9244 }
9245 if self.cascade {
9246 len += 1;
9247 }
9248 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
9249 if self.schema_id != 0 {
9250 struct_ser.serialize_field("schemaId", &self.schema_id)?;
9251 }
9252 if self.cascade {
9253 struct_ser.serialize_field("cascade", &self.cascade)?;
9254 }
9255 struct_ser.end()
9256 }
9257}
9258impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
9259 #[allow(deprecated)]
9260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9261 where
9262 D: serde::Deserializer<'de>,
9263 {
9264 const FIELDS: &[&str] = &[
9265 "schema_id",
9266 "schemaId",
9267 "cascade",
9268 ];
9269
9270 #[allow(clippy::enum_variant_names)]
9271 enum GeneratedField {
9272 SchemaId,
9273 Cascade,
9274 }
9275 impl<'de> serde::Deserialize<'de> for GeneratedField {
9276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9277 where
9278 D: serde::Deserializer<'de>,
9279 {
9280 struct GeneratedVisitor;
9281
9282 impl serde::de::Visitor<'_> for GeneratedVisitor {
9283 type Value = GeneratedField;
9284
9285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9286 write!(formatter, "expected one of: {:?}", &FIELDS)
9287 }
9288
9289 #[allow(unused_variables)]
9290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9291 where
9292 E: serde::de::Error,
9293 {
9294 match value {
9295 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
9296 "cascade" => Ok(GeneratedField::Cascade),
9297 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9298 }
9299 }
9300 }
9301 deserializer.deserialize_identifier(GeneratedVisitor)
9302 }
9303 }
9304 struct GeneratedVisitor;
9305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9306 type Value = DropSchemaRequest;
9307
9308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9309 formatter.write_str("struct ddl_service.DropSchemaRequest")
9310 }
9311
9312 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
9313 where
9314 V: serde::de::MapAccess<'de>,
9315 {
9316 let mut schema_id__ = None;
9317 let mut cascade__ = None;
9318 while let Some(k) = map_.next_key()? {
9319 match k {
9320 GeneratedField::SchemaId => {
9321 if schema_id__.is_some() {
9322 return Err(serde::de::Error::duplicate_field("schemaId"));
9323 }
9324 schema_id__ =
9325 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9326 ;
9327 }
9328 GeneratedField::Cascade => {
9329 if cascade__.is_some() {
9330 return Err(serde::de::Error::duplicate_field("cascade"));
9331 }
9332 cascade__ = Some(map_.next_value()?);
9333 }
9334 }
9335 }
9336 Ok(DropSchemaRequest {
9337 schema_id: schema_id__.unwrap_or_default(),
9338 cascade: cascade__.unwrap_or_default(),
9339 })
9340 }
9341 }
9342 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
9343 }
9344}
9345impl serde::Serialize for DropSchemaResponse {
9346 #[allow(deprecated)]
9347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9348 where
9349 S: serde::Serializer,
9350 {
9351 use serde::ser::SerializeStruct;
9352 let mut len = 0;
9353 if self.status.is_some() {
9354 len += 1;
9355 }
9356 if self.version.is_some() {
9357 len += 1;
9358 }
9359 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
9360 if let Some(v) = self.status.as_ref() {
9361 struct_ser.serialize_field("status", v)?;
9362 }
9363 if let Some(v) = self.version.as_ref() {
9364 struct_ser.serialize_field("version", v)?;
9365 }
9366 struct_ser.end()
9367 }
9368}
9369impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
9370 #[allow(deprecated)]
9371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9372 where
9373 D: serde::Deserializer<'de>,
9374 {
9375 const FIELDS: &[&str] = &[
9376 "status",
9377 "version",
9378 ];
9379
9380 #[allow(clippy::enum_variant_names)]
9381 enum GeneratedField {
9382 Status,
9383 Version,
9384 }
9385 impl<'de> serde::Deserialize<'de> for GeneratedField {
9386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9387 where
9388 D: serde::Deserializer<'de>,
9389 {
9390 struct GeneratedVisitor;
9391
9392 impl serde::de::Visitor<'_> for GeneratedVisitor {
9393 type Value = GeneratedField;
9394
9395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9396 write!(formatter, "expected one of: {:?}", &FIELDS)
9397 }
9398
9399 #[allow(unused_variables)]
9400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9401 where
9402 E: serde::de::Error,
9403 {
9404 match value {
9405 "status" => Ok(GeneratedField::Status),
9406 "version" => Ok(GeneratedField::Version),
9407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9408 }
9409 }
9410 }
9411 deserializer.deserialize_identifier(GeneratedVisitor)
9412 }
9413 }
9414 struct GeneratedVisitor;
9415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9416 type Value = DropSchemaResponse;
9417
9418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9419 formatter.write_str("struct ddl_service.DropSchemaResponse")
9420 }
9421
9422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
9423 where
9424 V: serde::de::MapAccess<'de>,
9425 {
9426 let mut status__ = None;
9427 let mut version__ = None;
9428 while let Some(k) = map_.next_key()? {
9429 match k {
9430 GeneratedField::Status => {
9431 if status__.is_some() {
9432 return Err(serde::de::Error::duplicate_field("status"));
9433 }
9434 status__ = map_.next_value()?;
9435 }
9436 GeneratedField::Version => {
9437 if version__.is_some() {
9438 return Err(serde::de::Error::duplicate_field("version"));
9439 }
9440 version__ = map_.next_value()?;
9441 }
9442 }
9443 }
9444 Ok(DropSchemaResponse {
9445 status: status__,
9446 version: version__,
9447 })
9448 }
9449 }
9450 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
9451 }
9452}
9453impl serde::Serialize for DropSecretRequest {
9454 #[allow(deprecated)]
9455 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9456 where
9457 S: serde::Serializer,
9458 {
9459 use serde::ser::SerializeStruct;
9460 let mut len = 0;
9461 if self.secret_id != 0 {
9462 len += 1;
9463 }
9464 if self.cascade {
9465 len += 1;
9466 }
9467 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
9468 if self.secret_id != 0 {
9469 struct_ser.serialize_field("secretId", &self.secret_id)?;
9470 }
9471 if self.cascade {
9472 struct_ser.serialize_field("cascade", &self.cascade)?;
9473 }
9474 struct_ser.end()
9475 }
9476}
9477impl<'de> serde::Deserialize<'de> for DropSecretRequest {
9478 #[allow(deprecated)]
9479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9480 where
9481 D: serde::Deserializer<'de>,
9482 {
9483 const FIELDS: &[&str] = &[
9484 "secret_id",
9485 "secretId",
9486 "cascade",
9487 ];
9488
9489 #[allow(clippy::enum_variant_names)]
9490 enum GeneratedField {
9491 SecretId,
9492 Cascade,
9493 }
9494 impl<'de> serde::Deserialize<'de> for GeneratedField {
9495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9496 where
9497 D: serde::Deserializer<'de>,
9498 {
9499 struct GeneratedVisitor;
9500
9501 impl serde::de::Visitor<'_> for GeneratedVisitor {
9502 type Value = GeneratedField;
9503
9504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9505 write!(formatter, "expected one of: {:?}", &FIELDS)
9506 }
9507
9508 #[allow(unused_variables)]
9509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9510 where
9511 E: serde::de::Error,
9512 {
9513 match value {
9514 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
9515 "cascade" => Ok(GeneratedField::Cascade),
9516 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9517 }
9518 }
9519 }
9520 deserializer.deserialize_identifier(GeneratedVisitor)
9521 }
9522 }
9523 struct GeneratedVisitor;
9524 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9525 type Value = DropSecretRequest;
9526
9527 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9528 formatter.write_str("struct ddl_service.DropSecretRequest")
9529 }
9530
9531 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
9532 where
9533 V: serde::de::MapAccess<'de>,
9534 {
9535 let mut secret_id__ = None;
9536 let mut cascade__ = None;
9537 while let Some(k) = map_.next_key()? {
9538 match k {
9539 GeneratedField::SecretId => {
9540 if secret_id__.is_some() {
9541 return Err(serde::de::Error::duplicate_field("secretId"));
9542 }
9543 secret_id__ =
9544 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9545 ;
9546 }
9547 GeneratedField::Cascade => {
9548 if cascade__.is_some() {
9549 return Err(serde::de::Error::duplicate_field("cascade"));
9550 }
9551 cascade__ = Some(map_.next_value()?);
9552 }
9553 }
9554 }
9555 Ok(DropSecretRequest {
9556 secret_id: secret_id__.unwrap_or_default(),
9557 cascade: cascade__.unwrap_or_default(),
9558 })
9559 }
9560 }
9561 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
9562 }
9563}
9564impl serde::Serialize for DropSecretResponse {
9565 #[allow(deprecated)]
9566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9567 where
9568 S: serde::Serializer,
9569 {
9570 use serde::ser::SerializeStruct;
9571 let mut len = 0;
9572 if self.version.is_some() {
9573 len += 1;
9574 }
9575 if self.status.is_some() {
9576 len += 1;
9577 }
9578 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
9579 if let Some(v) = self.version.as_ref() {
9580 struct_ser.serialize_field("version", v)?;
9581 }
9582 if let Some(v) = self.status.as_ref() {
9583 struct_ser.serialize_field("status", v)?;
9584 }
9585 struct_ser.end()
9586 }
9587}
9588impl<'de> serde::Deserialize<'de> for DropSecretResponse {
9589 #[allow(deprecated)]
9590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9591 where
9592 D: serde::Deserializer<'de>,
9593 {
9594 const FIELDS: &[&str] = &[
9595 "version",
9596 "status",
9597 ];
9598
9599 #[allow(clippy::enum_variant_names)]
9600 enum GeneratedField {
9601 Version,
9602 Status,
9603 }
9604 impl<'de> serde::Deserialize<'de> for GeneratedField {
9605 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9606 where
9607 D: serde::Deserializer<'de>,
9608 {
9609 struct GeneratedVisitor;
9610
9611 impl serde::de::Visitor<'_> for GeneratedVisitor {
9612 type Value = GeneratedField;
9613
9614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9615 write!(formatter, "expected one of: {:?}", &FIELDS)
9616 }
9617
9618 #[allow(unused_variables)]
9619 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9620 where
9621 E: serde::de::Error,
9622 {
9623 match value {
9624 "version" => Ok(GeneratedField::Version),
9625 "status" => Ok(GeneratedField::Status),
9626 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9627 }
9628 }
9629 }
9630 deserializer.deserialize_identifier(GeneratedVisitor)
9631 }
9632 }
9633 struct GeneratedVisitor;
9634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9635 type Value = DropSecretResponse;
9636
9637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9638 formatter.write_str("struct ddl_service.DropSecretResponse")
9639 }
9640
9641 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
9642 where
9643 V: serde::de::MapAccess<'de>,
9644 {
9645 let mut version__ = None;
9646 let mut status__ = None;
9647 while let Some(k) = map_.next_key()? {
9648 match k {
9649 GeneratedField::Version => {
9650 if version__.is_some() {
9651 return Err(serde::de::Error::duplicate_field("version"));
9652 }
9653 version__ = map_.next_value()?;
9654 }
9655 GeneratedField::Status => {
9656 if status__.is_some() {
9657 return Err(serde::de::Error::duplicate_field("status"));
9658 }
9659 status__ = map_.next_value()?;
9660 }
9661 }
9662 }
9663 Ok(DropSecretResponse {
9664 version: version__,
9665 status: status__,
9666 })
9667 }
9668 }
9669 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
9670 }
9671}
9672impl serde::Serialize for DropSinkRequest {
9673 #[allow(deprecated)]
9674 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9675 where
9676 S: serde::Serializer,
9677 {
9678 use serde::ser::SerializeStruct;
9679 let mut len = 0;
9680 if self.sink_id != 0 {
9681 len += 1;
9682 }
9683 if self.cascade {
9684 len += 1;
9685 }
9686 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
9687 if self.sink_id != 0 {
9688 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9689 }
9690 if self.cascade {
9691 struct_ser.serialize_field("cascade", &self.cascade)?;
9692 }
9693 struct_ser.end()
9694 }
9695}
9696impl<'de> serde::Deserialize<'de> for DropSinkRequest {
9697 #[allow(deprecated)]
9698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9699 where
9700 D: serde::Deserializer<'de>,
9701 {
9702 const FIELDS: &[&str] = &[
9703 "sink_id",
9704 "sinkId",
9705 "cascade",
9706 ];
9707
9708 #[allow(clippy::enum_variant_names)]
9709 enum GeneratedField {
9710 SinkId,
9711 Cascade,
9712 }
9713 impl<'de> serde::Deserialize<'de> for GeneratedField {
9714 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9715 where
9716 D: serde::Deserializer<'de>,
9717 {
9718 struct GeneratedVisitor;
9719
9720 impl serde::de::Visitor<'_> for GeneratedVisitor {
9721 type Value = GeneratedField;
9722
9723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9724 write!(formatter, "expected one of: {:?}", &FIELDS)
9725 }
9726
9727 #[allow(unused_variables)]
9728 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9729 where
9730 E: serde::de::Error,
9731 {
9732 match value {
9733 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9734 "cascade" => Ok(GeneratedField::Cascade),
9735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9736 }
9737 }
9738 }
9739 deserializer.deserialize_identifier(GeneratedVisitor)
9740 }
9741 }
9742 struct GeneratedVisitor;
9743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9744 type Value = DropSinkRequest;
9745
9746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9747 formatter.write_str("struct ddl_service.DropSinkRequest")
9748 }
9749
9750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
9751 where
9752 V: serde::de::MapAccess<'de>,
9753 {
9754 let mut sink_id__ = None;
9755 let mut cascade__ = None;
9756 while let Some(k) = map_.next_key()? {
9757 match k {
9758 GeneratedField::SinkId => {
9759 if sink_id__.is_some() {
9760 return Err(serde::de::Error::duplicate_field("sinkId"));
9761 }
9762 sink_id__ =
9763 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9764 ;
9765 }
9766 GeneratedField::Cascade => {
9767 if cascade__.is_some() {
9768 return Err(serde::de::Error::duplicate_field("cascade"));
9769 }
9770 cascade__ = Some(map_.next_value()?);
9771 }
9772 }
9773 }
9774 Ok(DropSinkRequest {
9775 sink_id: sink_id__.unwrap_or_default(),
9776 cascade: cascade__.unwrap_or_default(),
9777 })
9778 }
9779 }
9780 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
9781 }
9782}
9783impl serde::Serialize for DropSinkResponse {
9784 #[allow(deprecated)]
9785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9786 where
9787 S: serde::Serializer,
9788 {
9789 use serde::ser::SerializeStruct;
9790 let mut len = 0;
9791 if self.status.is_some() {
9792 len += 1;
9793 }
9794 if self.version.is_some() {
9795 len += 1;
9796 }
9797 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
9798 if let Some(v) = self.status.as_ref() {
9799 struct_ser.serialize_field("status", v)?;
9800 }
9801 if let Some(v) = self.version.as_ref() {
9802 struct_ser.serialize_field("version", v)?;
9803 }
9804 struct_ser.end()
9805 }
9806}
9807impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9808 #[allow(deprecated)]
9809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9810 where
9811 D: serde::Deserializer<'de>,
9812 {
9813 const FIELDS: &[&str] = &[
9814 "status",
9815 "version",
9816 ];
9817
9818 #[allow(clippy::enum_variant_names)]
9819 enum GeneratedField {
9820 Status,
9821 Version,
9822 }
9823 impl<'de> serde::Deserialize<'de> for GeneratedField {
9824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9825 where
9826 D: serde::Deserializer<'de>,
9827 {
9828 struct GeneratedVisitor;
9829
9830 impl serde::de::Visitor<'_> for GeneratedVisitor {
9831 type Value = GeneratedField;
9832
9833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9834 write!(formatter, "expected one of: {:?}", &FIELDS)
9835 }
9836
9837 #[allow(unused_variables)]
9838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9839 where
9840 E: serde::de::Error,
9841 {
9842 match value {
9843 "status" => Ok(GeneratedField::Status),
9844 "version" => Ok(GeneratedField::Version),
9845 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9846 }
9847 }
9848 }
9849 deserializer.deserialize_identifier(GeneratedVisitor)
9850 }
9851 }
9852 struct GeneratedVisitor;
9853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9854 type Value = DropSinkResponse;
9855
9856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9857 formatter.write_str("struct ddl_service.DropSinkResponse")
9858 }
9859
9860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9861 where
9862 V: serde::de::MapAccess<'de>,
9863 {
9864 let mut status__ = None;
9865 let mut version__ = None;
9866 while let Some(k) = map_.next_key()? {
9867 match k {
9868 GeneratedField::Status => {
9869 if status__.is_some() {
9870 return Err(serde::de::Error::duplicate_field("status"));
9871 }
9872 status__ = map_.next_value()?;
9873 }
9874 GeneratedField::Version => {
9875 if version__.is_some() {
9876 return Err(serde::de::Error::duplicate_field("version"));
9877 }
9878 version__ = map_.next_value()?;
9879 }
9880 }
9881 }
9882 Ok(DropSinkResponse {
9883 status: status__,
9884 version: version__,
9885 })
9886 }
9887 }
9888 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9889 }
9890}
9891impl serde::Serialize for DropSourceRequest {
9892 #[allow(deprecated)]
9893 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9894 where
9895 S: serde::Serializer,
9896 {
9897 use serde::ser::SerializeStruct;
9898 let mut len = 0;
9899 if self.source_id != 0 {
9900 len += 1;
9901 }
9902 if self.cascade {
9903 len += 1;
9904 }
9905 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9906 if self.source_id != 0 {
9907 struct_ser.serialize_field("sourceId", &self.source_id)?;
9908 }
9909 if self.cascade {
9910 struct_ser.serialize_field("cascade", &self.cascade)?;
9911 }
9912 struct_ser.end()
9913 }
9914}
9915impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9916 #[allow(deprecated)]
9917 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9918 where
9919 D: serde::Deserializer<'de>,
9920 {
9921 const FIELDS: &[&str] = &[
9922 "source_id",
9923 "sourceId",
9924 "cascade",
9925 ];
9926
9927 #[allow(clippy::enum_variant_names)]
9928 enum GeneratedField {
9929 SourceId,
9930 Cascade,
9931 }
9932 impl<'de> serde::Deserialize<'de> for GeneratedField {
9933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9934 where
9935 D: serde::Deserializer<'de>,
9936 {
9937 struct GeneratedVisitor;
9938
9939 impl serde::de::Visitor<'_> for GeneratedVisitor {
9940 type Value = GeneratedField;
9941
9942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9943 write!(formatter, "expected one of: {:?}", &FIELDS)
9944 }
9945
9946 #[allow(unused_variables)]
9947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9948 where
9949 E: serde::de::Error,
9950 {
9951 match value {
9952 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9953 "cascade" => Ok(GeneratedField::Cascade),
9954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9955 }
9956 }
9957 }
9958 deserializer.deserialize_identifier(GeneratedVisitor)
9959 }
9960 }
9961 struct GeneratedVisitor;
9962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9963 type Value = DropSourceRequest;
9964
9965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9966 formatter.write_str("struct ddl_service.DropSourceRequest")
9967 }
9968
9969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9970 where
9971 V: serde::de::MapAccess<'de>,
9972 {
9973 let mut source_id__ = None;
9974 let mut cascade__ = None;
9975 while let Some(k) = map_.next_key()? {
9976 match k {
9977 GeneratedField::SourceId => {
9978 if source_id__.is_some() {
9979 return Err(serde::de::Error::duplicate_field("sourceId"));
9980 }
9981 source_id__ =
9982 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9983 ;
9984 }
9985 GeneratedField::Cascade => {
9986 if cascade__.is_some() {
9987 return Err(serde::de::Error::duplicate_field("cascade"));
9988 }
9989 cascade__ = Some(map_.next_value()?);
9990 }
9991 }
9992 }
9993 Ok(DropSourceRequest {
9994 source_id: source_id__.unwrap_or_default(),
9995 cascade: cascade__.unwrap_or_default(),
9996 })
9997 }
9998 }
9999 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
10000 }
10001}
10002impl serde::Serialize for DropSourceResponse {
10003 #[allow(deprecated)]
10004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10005 where
10006 S: serde::Serializer,
10007 {
10008 use serde::ser::SerializeStruct;
10009 let mut len = 0;
10010 if self.status.is_some() {
10011 len += 1;
10012 }
10013 if self.version.is_some() {
10014 len += 1;
10015 }
10016 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
10017 if let Some(v) = self.status.as_ref() {
10018 struct_ser.serialize_field("status", v)?;
10019 }
10020 if let Some(v) = self.version.as_ref() {
10021 struct_ser.serialize_field("version", v)?;
10022 }
10023 struct_ser.end()
10024 }
10025}
10026impl<'de> serde::Deserialize<'de> for DropSourceResponse {
10027 #[allow(deprecated)]
10028 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10029 where
10030 D: serde::Deserializer<'de>,
10031 {
10032 const FIELDS: &[&str] = &[
10033 "status",
10034 "version",
10035 ];
10036
10037 #[allow(clippy::enum_variant_names)]
10038 enum GeneratedField {
10039 Status,
10040 Version,
10041 }
10042 impl<'de> serde::Deserialize<'de> for GeneratedField {
10043 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10044 where
10045 D: serde::Deserializer<'de>,
10046 {
10047 struct GeneratedVisitor;
10048
10049 impl serde::de::Visitor<'_> for GeneratedVisitor {
10050 type Value = GeneratedField;
10051
10052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10053 write!(formatter, "expected one of: {:?}", &FIELDS)
10054 }
10055
10056 #[allow(unused_variables)]
10057 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10058 where
10059 E: serde::de::Error,
10060 {
10061 match value {
10062 "status" => Ok(GeneratedField::Status),
10063 "version" => Ok(GeneratedField::Version),
10064 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10065 }
10066 }
10067 }
10068 deserializer.deserialize_identifier(GeneratedVisitor)
10069 }
10070 }
10071 struct GeneratedVisitor;
10072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10073 type Value = DropSourceResponse;
10074
10075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10076 formatter.write_str("struct ddl_service.DropSourceResponse")
10077 }
10078
10079 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
10080 where
10081 V: serde::de::MapAccess<'de>,
10082 {
10083 let mut status__ = None;
10084 let mut version__ = None;
10085 while let Some(k) = map_.next_key()? {
10086 match k {
10087 GeneratedField::Status => {
10088 if status__.is_some() {
10089 return Err(serde::de::Error::duplicate_field("status"));
10090 }
10091 status__ = map_.next_value()?;
10092 }
10093 GeneratedField::Version => {
10094 if version__.is_some() {
10095 return Err(serde::de::Error::duplicate_field("version"));
10096 }
10097 version__ = map_.next_value()?;
10098 }
10099 }
10100 }
10101 Ok(DropSourceResponse {
10102 status: status__,
10103 version: version__,
10104 })
10105 }
10106 }
10107 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
10108 }
10109}
10110impl serde::Serialize for DropSubscriptionRequest {
10111 #[allow(deprecated)]
10112 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10113 where
10114 S: serde::Serializer,
10115 {
10116 use serde::ser::SerializeStruct;
10117 let mut len = 0;
10118 if self.subscription_id != 0 {
10119 len += 1;
10120 }
10121 if self.cascade {
10122 len += 1;
10123 }
10124 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
10125 if self.subscription_id != 0 {
10126 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
10127 }
10128 if self.cascade {
10129 struct_ser.serialize_field("cascade", &self.cascade)?;
10130 }
10131 struct_ser.end()
10132 }
10133}
10134impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
10135 #[allow(deprecated)]
10136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10137 where
10138 D: serde::Deserializer<'de>,
10139 {
10140 const FIELDS: &[&str] = &[
10141 "subscription_id",
10142 "subscriptionId",
10143 "cascade",
10144 ];
10145
10146 #[allow(clippy::enum_variant_names)]
10147 enum GeneratedField {
10148 SubscriptionId,
10149 Cascade,
10150 }
10151 impl<'de> serde::Deserialize<'de> for GeneratedField {
10152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10153 where
10154 D: serde::Deserializer<'de>,
10155 {
10156 struct GeneratedVisitor;
10157
10158 impl serde::de::Visitor<'_> for GeneratedVisitor {
10159 type Value = GeneratedField;
10160
10161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10162 write!(formatter, "expected one of: {:?}", &FIELDS)
10163 }
10164
10165 #[allow(unused_variables)]
10166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10167 where
10168 E: serde::de::Error,
10169 {
10170 match value {
10171 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
10172 "cascade" => Ok(GeneratedField::Cascade),
10173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10174 }
10175 }
10176 }
10177 deserializer.deserialize_identifier(GeneratedVisitor)
10178 }
10179 }
10180 struct GeneratedVisitor;
10181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10182 type Value = DropSubscriptionRequest;
10183
10184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10185 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
10186 }
10187
10188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
10189 where
10190 V: serde::de::MapAccess<'de>,
10191 {
10192 let mut subscription_id__ = None;
10193 let mut cascade__ = None;
10194 while let Some(k) = map_.next_key()? {
10195 match k {
10196 GeneratedField::SubscriptionId => {
10197 if subscription_id__.is_some() {
10198 return Err(serde::de::Error::duplicate_field("subscriptionId"));
10199 }
10200 subscription_id__ =
10201 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10202 ;
10203 }
10204 GeneratedField::Cascade => {
10205 if cascade__.is_some() {
10206 return Err(serde::de::Error::duplicate_field("cascade"));
10207 }
10208 cascade__ = Some(map_.next_value()?);
10209 }
10210 }
10211 }
10212 Ok(DropSubscriptionRequest {
10213 subscription_id: subscription_id__.unwrap_or_default(),
10214 cascade: cascade__.unwrap_or_default(),
10215 })
10216 }
10217 }
10218 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
10219 }
10220}
10221impl serde::Serialize for DropSubscriptionResponse {
10222 #[allow(deprecated)]
10223 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10224 where
10225 S: serde::Serializer,
10226 {
10227 use serde::ser::SerializeStruct;
10228 let mut len = 0;
10229 if self.status.is_some() {
10230 len += 1;
10231 }
10232 if self.version.is_some() {
10233 len += 1;
10234 }
10235 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
10236 if let Some(v) = self.status.as_ref() {
10237 struct_ser.serialize_field("status", v)?;
10238 }
10239 if let Some(v) = self.version.as_ref() {
10240 struct_ser.serialize_field("version", v)?;
10241 }
10242 struct_ser.end()
10243 }
10244}
10245impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
10246 #[allow(deprecated)]
10247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10248 where
10249 D: serde::Deserializer<'de>,
10250 {
10251 const FIELDS: &[&str] = &[
10252 "status",
10253 "version",
10254 ];
10255
10256 #[allow(clippy::enum_variant_names)]
10257 enum GeneratedField {
10258 Status,
10259 Version,
10260 }
10261 impl<'de> serde::Deserialize<'de> for GeneratedField {
10262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10263 where
10264 D: serde::Deserializer<'de>,
10265 {
10266 struct GeneratedVisitor;
10267
10268 impl serde::de::Visitor<'_> for GeneratedVisitor {
10269 type Value = GeneratedField;
10270
10271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10272 write!(formatter, "expected one of: {:?}", &FIELDS)
10273 }
10274
10275 #[allow(unused_variables)]
10276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10277 where
10278 E: serde::de::Error,
10279 {
10280 match value {
10281 "status" => Ok(GeneratedField::Status),
10282 "version" => Ok(GeneratedField::Version),
10283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10284 }
10285 }
10286 }
10287 deserializer.deserialize_identifier(GeneratedVisitor)
10288 }
10289 }
10290 struct GeneratedVisitor;
10291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10292 type Value = DropSubscriptionResponse;
10293
10294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10295 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
10296 }
10297
10298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
10299 where
10300 V: serde::de::MapAccess<'de>,
10301 {
10302 let mut status__ = None;
10303 let mut version__ = None;
10304 while let Some(k) = map_.next_key()? {
10305 match k {
10306 GeneratedField::Status => {
10307 if status__.is_some() {
10308 return Err(serde::de::Error::duplicate_field("status"));
10309 }
10310 status__ = map_.next_value()?;
10311 }
10312 GeneratedField::Version => {
10313 if version__.is_some() {
10314 return Err(serde::de::Error::duplicate_field("version"));
10315 }
10316 version__ = map_.next_value()?;
10317 }
10318 }
10319 }
10320 Ok(DropSubscriptionResponse {
10321 status: status__,
10322 version: version__,
10323 })
10324 }
10325 }
10326 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
10327 }
10328}
10329impl serde::Serialize for DropTableRequest {
10330 #[allow(deprecated)]
10331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10332 where
10333 S: serde::Serializer,
10334 {
10335 use serde::ser::SerializeStruct;
10336 let mut len = 0;
10337 if self.table_id != 0 {
10338 len += 1;
10339 }
10340 if self.cascade {
10341 len += 1;
10342 }
10343 if self.source_id.is_some() {
10344 len += 1;
10345 }
10346 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
10347 if self.table_id != 0 {
10348 struct_ser.serialize_field("tableId", &self.table_id)?;
10349 }
10350 if self.cascade {
10351 struct_ser.serialize_field("cascade", &self.cascade)?;
10352 }
10353 if let Some(v) = self.source_id.as_ref() {
10354 match v {
10355 drop_table_request::SourceId::Id(v) => {
10356 struct_ser.serialize_field("id", v)?;
10357 }
10358 }
10359 }
10360 struct_ser.end()
10361 }
10362}
10363impl<'de> serde::Deserialize<'de> for DropTableRequest {
10364 #[allow(deprecated)]
10365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10366 where
10367 D: serde::Deserializer<'de>,
10368 {
10369 const FIELDS: &[&str] = &[
10370 "table_id",
10371 "tableId",
10372 "cascade",
10373 "id",
10374 ];
10375
10376 #[allow(clippy::enum_variant_names)]
10377 enum GeneratedField {
10378 TableId,
10379 Cascade,
10380 Id,
10381 }
10382 impl<'de> serde::Deserialize<'de> for GeneratedField {
10383 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10384 where
10385 D: serde::Deserializer<'de>,
10386 {
10387 struct GeneratedVisitor;
10388
10389 impl serde::de::Visitor<'_> for GeneratedVisitor {
10390 type Value = GeneratedField;
10391
10392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10393 write!(formatter, "expected one of: {:?}", &FIELDS)
10394 }
10395
10396 #[allow(unused_variables)]
10397 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10398 where
10399 E: serde::de::Error,
10400 {
10401 match value {
10402 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10403 "cascade" => Ok(GeneratedField::Cascade),
10404 "id" => Ok(GeneratedField::Id),
10405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10406 }
10407 }
10408 }
10409 deserializer.deserialize_identifier(GeneratedVisitor)
10410 }
10411 }
10412 struct GeneratedVisitor;
10413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10414 type Value = DropTableRequest;
10415
10416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10417 formatter.write_str("struct ddl_service.DropTableRequest")
10418 }
10419
10420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
10421 where
10422 V: serde::de::MapAccess<'de>,
10423 {
10424 let mut table_id__ = None;
10425 let mut cascade__ = None;
10426 let mut source_id__ = None;
10427 while let Some(k) = map_.next_key()? {
10428 match k {
10429 GeneratedField::TableId => {
10430 if table_id__.is_some() {
10431 return Err(serde::de::Error::duplicate_field("tableId"));
10432 }
10433 table_id__ =
10434 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10435 ;
10436 }
10437 GeneratedField::Cascade => {
10438 if cascade__.is_some() {
10439 return Err(serde::de::Error::duplicate_field("cascade"));
10440 }
10441 cascade__ = Some(map_.next_value()?);
10442 }
10443 GeneratedField::Id => {
10444 if source_id__.is_some() {
10445 return Err(serde::de::Error::duplicate_field("id"));
10446 }
10447 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
10448 }
10449 }
10450 }
10451 Ok(DropTableRequest {
10452 table_id: table_id__.unwrap_or_default(),
10453 cascade: cascade__.unwrap_or_default(),
10454 source_id: source_id__,
10455 })
10456 }
10457 }
10458 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
10459 }
10460}
10461impl serde::Serialize for DropTableResponse {
10462 #[allow(deprecated)]
10463 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10464 where
10465 S: serde::Serializer,
10466 {
10467 use serde::ser::SerializeStruct;
10468 let mut len = 0;
10469 if self.status.is_some() {
10470 len += 1;
10471 }
10472 if self.version.is_some() {
10473 len += 1;
10474 }
10475 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
10476 if let Some(v) = self.status.as_ref() {
10477 struct_ser.serialize_field("status", v)?;
10478 }
10479 if let Some(v) = self.version.as_ref() {
10480 struct_ser.serialize_field("version", v)?;
10481 }
10482 struct_ser.end()
10483 }
10484}
10485impl<'de> serde::Deserialize<'de> for DropTableResponse {
10486 #[allow(deprecated)]
10487 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10488 where
10489 D: serde::Deserializer<'de>,
10490 {
10491 const FIELDS: &[&str] = &[
10492 "status",
10493 "version",
10494 ];
10495
10496 #[allow(clippy::enum_variant_names)]
10497 enum GeneratedField {
10498 Status,
10499 Version,
10500 }
10501 impl<'de> serde::Deserialize<'de> for GeneratedField {
10502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10503 where
10504 D: serde::Deserializer<'de>,
10505 {
10506 struct GeneratedVisitor;
10507
10508 impl serde::de::Visitor<'_> for GeneratedVisitor {
10509 type Value = GeneratedField;
10510
10511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10512 write!(formatter, "expected one of: {:?}", &FIELDS)
10513 }
10514
10515 #[allow(unused_variables)]
10516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10517 where
10518 E: serde::de::Error,
10519 {
10520 match value {
10521 "status" => Ok(GeneratedField::Status),
10522 "version" => Ok(GeneratedField::Version),
10523 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10524 }
10525 }
10526 }
10527 deserializer.deserialize_identifier(GeneratedVisitor)
10528 }
10529 }
10530 struct GeneratedVisitor;
10531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10532 type Value = DropTableResponse;
10533
10534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10535 formatter.write_str("struct ddl_service.DropTableResponse")
10536 }
10537
10538 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
10539 where
10540 V: serde::de::MapAccess<'de>,
10541 {
10542 let mut status__ = None;
10543 let mut version__ = None;
10544 while let Some(k) = map_.next_key()? {
10545 match k {
10546 GeneratedField::Status => {
10547 if status__.is_some() {
10548 return Err(serde::de::Error::duplicate_field("status"));
10549 }
10550 status__ = map_.next_value()?;
10551 }
10552 GeneratedField::Version => {
10553 if version__.is_some() {
10554 return Err(serde::de::Error::duplicate_field("version"));
10555 }
10556 version__ = map_.next_value()?;
10557 }
10558 }
10559 }
10560 Ok(DropTableResponse {
10561 status: status__,
10562 version: version__,
10563 })
10564 }
10565 }
10566 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
10567 }
10568}
10569impl serde::Serialize for DropViewRequest {
10570 #[allow(deprecated)]
10571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10572 where
10573 S: serde::Serializer,
10574 {
10575 use serde::ser::SerializeStruct;
10576 let mut len = 0;
10577 if self.view_id != 0 {
10578 len += 1;
10579 }
10580 if self.cascade {
10581 len += 1;
10582 }
10583 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
10584 if self.view_id != 0 {
10585 struct_ser.serialize_field("viewId", &self.view_id)?;
10586 }
10587 if self.cascade {
10588 struct_ser.serialize_field("cascade", &self.cascade)?;
10589 }
10590 struct_ser.end()
10591 }
10592}
10593impl<'de> serde::Deserialize<'de> for DropViewRequest {
10594 #[allow(deprecated)]
10595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10596 where
10597 D: serde::Deserializer<'de>,
10598 {
10599 const FIELDS: &[&str] = &[
10600 "view_id",
10601 "viewId",
10602 "cascade",
10603 ];
10604
10605 #[allow(clippy::enum_variant_names)]
10606 enum GeneratedField {
10607 ViewId,
10608 Cascade,
10609 }
10610 impl<'de> serde::Deserialize<'de> for GeneratedField {
10611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10612 where
10613 D: serde::Deserializer<'de>,
10614 {
10615 struct GeneratedVisitor;
10616
10617 impl serde::de::Visitor<'_> for GeneratedVisitor {
10618 type Value = GeneratedField;
10619
10620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10621 write!(formatter, "expected one of: {:?}", &FIELDS)
10622 }
10623
10624 #[allow(unused_variables)]
10625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10626 where
10627 E: serde::de::Error,
10628 {
10629 match value {
10630 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
10631 "cascade" => Ok(GeneratedField::Cascade),
10632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10633 }
10634 }
10635 }
10636 deserializer.deserialize_identifier(GeneratedVisitor)
10637 }
10638 }
10639 struct GeneratedVisitor;
10640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10641 type Value = DropViewRequest;
10642
10643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10644 formatter.write_str("struct ddl_service.DropViewRequest")
10645 }
10646
10647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
10648 where
10649 V: serde::de::MapAccess<'de>,
10650 {
10651 let mut view_id__ = None;
10652 let mut cascade__ = None;
10653 while let Some(k) = map_.next_key()? {
10654 match k {
10655 GeneratedField::ViewId => {
10656 if view_id__.is_some() {
10657 return Err(serde::de::Error::duplicate_field("viewId"));
10658 }
10659 view_id__ =
10660 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10661 ;
10662 }
10663 GeneratedField::Cascade => {
10664 if cascade__.is_some() {
10665 return Err(serde::de::Error::duplicate_field("cascade"));
10666 }
10667 cascade__ = Some(map_.next_value()?);
10668 }
10669 }
10670 }
10671 Ok(DropViewRequest {
10672 view_id: view_id__.unwrap_or_default(),
10673 cascade: cascade__.unwrap_or_default(),
10674 })
10675 }
10676 }
10677 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
10678 }
10679}
10680impl serde::Serialize for DropViewResponse {
10681 #[allow(deprecated)]
10682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10683 where
10684 S: serde::Serializer,
10685 {
10686 use serde::ser::SerializeStruct;
10687 let mut len = 0;
10688 if self.status.is_some() {
10689 len += 1;
10690 }
10691 if self.version.is_some() {
10692 len += 1;
10693 }
10694 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
10695 if let Some(v) = self.status.as_ref() {
10696 struct_ser.serialize_field("status", v)?;
10697 }
10698 if let Some(v) = self.version.as_ref() {
10699 struct_ser.serialize_field("version", v)?;
10700 }
10701 struct_ser.end()
10702 }
10703}
10704impl<'de> serde::Deserialize<'de> for DropViewResponse {
10705 #[allow(deprecated)]
10706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10707 where
10708 D: serde::Deserializer<'de>,
10709 {
10710 const FIELDS: &[&str] = &[
10711 "status",
10712 "version",
10713 ];
10714
10715 #[allow(clippy::enum_variant_names)]
10716 enum GeneratedField {
10717 Status,
10718 Version,
10719 }
10720 impl<'de> serde::Deserialize<'de> for GeneratedField {
10721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10722 where
10723 D: serde::Deserializer<'de>,
10724 {
10725 struct GeneratedVisitor;
10726
10727 impl serde::de::Visitor<'_> for GeneratedVisitor {
10728 type Value = GeneratedField;
10729
10730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10731 write!(formatter, "expected one of: {:?}", &FIELDS)
10732 }
10733
10734 #[allow(unused_variables)]
10735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10736 where
10737 E: serde::de::Error,
10738 {
10739 match value {
10740 "status" => Ok(GeneratedField::Status),
10741 "version" => Ok(GeneratedField::Version),
10742 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10743 }
10744 }
10745 }
10746 deserializer.deserialize_identifier(GeneratedVisitor)
10747 }
10748 }
10749 struct GeneratedVisitor;
10750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10751 type Value = DropViewResponse;
10752
10753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10754 formatter.write_str("struct ddl_service.DropViewResponse")
10755 }
10756
10757 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
10758 where
10759 V: serde::de::MapAccess<'de>,
10760 {
10761 let mut status__ = None;
10762 let mut version__ = None;
10763 while let Some(k) = map_.next_key()? {
10764 match k {
10765 GeneratedField::Status => {
10766 if status__.is_some() {
10767 return Err(serde::de::Error::duplicate_field("status"));
10768 }
10769 status__ = map_.next_value()?;
10770 }
10771 GeneratedField::Version => {
10772 if version__.is_some() {
10773 return Err(serde::de::Error::duplicate_field("version"));
10774 }
10775 version__ = map_.next_value()?;
10776 }
10777 }
10778 }
10779 Ok(DropViewResponse {
10780 status: status__,
10781 version: version__,
10782 })
10783 }
10784 }
10785 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
10786 }
10787}
10788impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
10789 #[allow(deprecated)]
10790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10791 where
10792 S: serde::Serializer,
10793 {
10794 use serde::ser::SerializeStruct;
10795 let mut len = 0;
10796 if self.sink_id != 0 {
10797 len += 1;
10798 }
10799 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
10800 if self.sink_id != 0 {
10801 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10802 }
10803 struct_ser.end()
10804 }
10805}
10806impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10807 #[allow(deprecated)]
10808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10809 where
10810 D: serde::Deserializer<'de>,
10811 {
10812 const FIELDS: &[&str] = &[
10813 "sink_id",
10814 "sinkId",
10815 ];
10816
10817 #[allow(clippy::enum_variant_names)]
10818 enum GeneratedField {
10819 SinkId,
10820 }
10821 impl<'de> serde::Deserialize<'de> for GeneratedField {
10822 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10823 where
10824 D: serde::Deserializer<'de>,
10825 {
10826 struct GeneratedVisitor;
10827
10828 impl serde::de::Visitor<'_> for GeneratedVisitor {
10829 type Value = GeneratedField;
10830
10831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10832 write!(formatter, "expected one of: {:?}", &FIELDS)
10833 }
10834
10835 #[allow(unused_variables)]
10836 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10837 where
10838 E: serde::de::Error,
10839 {
10840 match value {
10841 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10842 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10843 }
10844 }
10845 }
10846 deserializer.deserialize_identifier(GeneratedVisitor)
10847 }
10848 }
10849 struct GeneratedVisitor;
10850 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10851 type Value = ExpireIcebergTableSnapshotsRequest;
10852
10853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10854 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10855 }
10856
10857 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10858 where
10859 V: serde::de::MapAccess<'de>,
10860 {
10861 let mut sink_id__ = None;
10862 while let Some(k) = map_.next_key()? {
10863 match k {
10864 GeneratedField::SinkId => {
10865 if sink_id__.is_some() {
10866 return Err(serde::de::Error::duplicate_field("sinkId"));
10867 }
10868 sink_id__ =
10869 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10870 ;
10871 }
10872 }
10873 }
10874 Ok(ExpireIcebergTableSnapshotsRequest {
10875 sink_id: sink_id__.unwrap_or_default(),
10876 })
10877 }
10878 }
10879 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10880 }
10881}
10882impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10883 #[allow(deprecated)]
10884 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10885 where
10886 S: serde::Serializer,
10887 {
10888 use serde::ser::SerializeStruct;
10889 let mut len = 0;
10890 if self.status.is_some() {
10891 len += 1;
10892 }
10893 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10894 if let Some(v) = self.status.as_ref() {
10895 struct_ser.serialize_field("status", v)?;
10896 }
10897 struct_ser.end()
10898 }
10899}
10900impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10901 #[allow(deprecated)]
10902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10903 where
10904 D: serde::Deserializer<'de>,
10905 {
10906 const FIELDS: &[&str] = &[
10907 "status",
10908 ];
10909
10910 #[allow(clippy::enum_variant_names)]
10911 enum GeneratedField {
10912 Status,
10913 }
10914 impl<'de> serde::Deserialize<'de> for GeneratedField {
10915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10916 where
10917 D: serde::Deserializer<'de>,
10918 {
10919 struct GeneratedVisitor;
10920
10921 impl serde::de::Visitor<'_> for GeneratedVisitor {
10922 type Value = GeneratedField;
10923
10924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10925 write!(formatter, "expected one of: {:?}", &FIELDS)
10926 }
10927
10928 #[allow(unused_variables)]
10929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10930 where
10931 E: serde::de::Error,
10932 {
10933 match value {
10934 "status" => Ok(GeneratedField::Status),
10935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10936 }
10937 }
10938 }
10939 deserializer.deserialize_identifier(GeneratedVisitor)
10940 }
10941 }
10942 struct GeneratedVisitor;
10943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10944 type Value = ExpireIcebergTableSnapshotsResponse;
10945
10946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10947 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10948 }
10949
10950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10951 where
10952 V: serde::de::MapAccess<'de>,
10953 {
10954 let mut status__ = None;
10955 while let Some(k) = map_.next_key()? {
10956 match k {
10957 GeneratedField::Status => {
10958 if status__.is_some() {
10959 return Err(serde::de::Error::duplicate_field("status"));
10960 }
10961 status__ = map_.next_value()?;
10962 }
10963 }
10964 }
10965 Ok(ExpireIcebergTableSnapshotsResponse {
10966 status: status__,
10967 })
10968 }
10969 }
10970 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10971 }
10972}
10973impl serde::Serialize for GetDdlProgressRequest {
10974 #[allow(deprecated)]
10975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10976 where
10977 S: serde::Serializer,
10978 {
10979 use serde::ser::SerializeStruct;
10980 let len = 0;
10981 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10982 struct_ser.end()
10983 }
10984}
10985impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10986 #[allow(deprecated)]
10987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10988 where
10989 D: serde::Deserializer<'de>,
10990 {
10991 const FIELDS: &[&str] = &[
10992 ];
10993
10994 #[allow(clippy::enum_variant_names)]
10995 enum GeneratedField {
10996 }
10997 impl<'de> serde::Deserialize<'de> for GeneratedField {
10998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10999 where
11000 D: serde::Deserializer<'de>,
11001 {
11002 struct GeneratedVisitor;
11003
11004 impl serde::de::Visitor<'_> for GeneratedVisitor {
11005 type Value = GeneratedField;
11006
11007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11008 write!(formatter, "expected one of: {:?}", &FIELDS)
11009 }
11010
11011 #[allow(unused_variables)]
11012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11013 where
11014 E: serde::de::Error,
11015 {
11016 Err(serde::de::Error::unknown_field(value, FIELDS))
11017 }
11018 }
11019 deserializer.deserialize_identifier(GeneratedVisitor)
11020 }
11021 }
11022 struct GeneratedVisitor;
11023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11024 type Value = GetDdlProgressRequest;
11025
11026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11027 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
11028 }
11029
11030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
11031 where
11032 V: serde::de::MapAccess<'de>,
11033 {
11034 while map_.next_key::<GeneratedField>()?.is_some() {
11035 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11036 }
11037 Ok(GetDdlProgressRequest {
11038 })
11039 }
11040 }
11041 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
11042 }
11043}
11044impl serde::Serialize for GetDdlProgressResponse {
11045 #[allow(deprecated)]
11046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11047 where
11048 S: serde::Serializer,
11049 {
11050 use serde::ser::SerializeStruct;
11051 let mut len = 0;
11052 if !self.ddl_progress.is_empty() {
11053 len += 1;
11054 }
11055 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
11056 if !self.ddl_progress.is_empty() {
11057 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
11058 }
11059 struct_ser.end()
11060 }
11061}
11062impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
11063 #[allow(deprecated)]
11064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11065 where
11066 D: serde::Deserializer<'de>,
11067 {
11068 const FIELDS: &[&str] = &[
11069 "ddl_progress",
11070 "ddlProgress",
11071 ];
11072
11073 #[allow(clippy::enum_variant_names)]
11074 enum GeneratedField {
11075 DdlProgress,
11076 }
11077 impl<'de> serde::Deserialize<'de> for GeneratedField {
11078 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11079 where
11080 D: serde::Deserializer<'de>,
11081 {
11082 struct GeneratedVisitor;
11083
11084 impl serde::de::Visitor<'_> for GeneratedVisitor {
11085 type Value = GeneratedField;
11086
11087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11088 write!(formatter, "expected one of: {:?}", &FIELDS)
11089 }
11090
11091 #[allow(unused_variables)]
11092 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11093 where
11094 E: serde::de::Error,
11095 {
11096 match value {
11097 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
11098 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11099 }
11100 }
11101 }
11102 deserializer.deserialize_identifier(GeneratedVisitor)
11103 }
11104 }
11105 struct GeneratedVisitor;
11106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11107 type Value = GetDdlProgressResponse;
11108
11109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11110 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
11111 }
11112
11113 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
11114 where
11115 V: serde::de::MapAccess<'de>,
11116 {
11117 let mut ddl_progress__ = None;
11118 while let Some(k) = map_.next_key()? {
11119 match k {
11120 GeneratedField::DdlProgress => {
11121 if ddl_progress__.is_some() {
11122 return Err(serde::de::Error::duplicate_field("ddlProgress"));
11123 }
11124 ddl_progress__ = Some(map_.next_value()?);
11125 }
11126 }
11127 }
11128 Ok(GetDdlProgressResponse {
11129 ddl_progress: ddl_progress__.unwrap_or_default(),
11130 })
11131 }
11132 }
11133 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
11134 }
11135}
11136impl serde::Serialize for GetTableRequest {
11137 #[allow(deprecated)]
11138 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11139 where
11140 S: serde::Serializer,
11141 {
11142 use serde::ser::SerializeStruct;
11143 let mut len = 0;
11144 if !self.database_name.is_empty() {
11145 len += 1;
11146 }
11147 if !self.table_name.is_empty() {
11148 len += 1;
11149 }
11150 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
11151 if !self.database_name.is_empty() {
11152 struct_ser.serialize_field("databaseName", &self.database_name)?;
11153 }
11154 if !self.table_name.is_empty() {
11155 struct_ser.serialize_field("tableName", &self.table_name)?;
11156 }
11157 struct_ser.end()
11158 }
11159}
11160impl<'de> serde::Deserialize<'de> for GetTableRequest {
11161 #[allow(deprecated)]
11162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11163 where
11164 D: serde::Deserializer<'de>,
11165 {
11166 const FIELDS: &[&str] = &[
11167 "database_name",
11168 "databaseName",
11169 "table_name",
11170 "tableName",
11171 ];
11172
11173 #[allow(clippy::enum_variant_names)]
11174 enum GeneratedField {
11175 DatabaseName,
11176 TableName,
11177 }
11178 impl<'de> serde::Deserialize<'de> for GeneratedField {
11179 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11180 where
11181 D: serde::Deserializer<'de>,
11182 {
11183 struct GeneratedVisitor;
11184
11185 impl serde::de::Visitor<'_> for GeneratedVisitor {
11186 type Value = GeneratedField;
11187
11188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11189 write!(formatter, "expected one of: {:?}", &FIELDS)
11190 }
11191
11192 #[allow(unused_variables)]
11193 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11194 where
11195 E: serde::de::Error,
11196 {
11197 match value {
11198 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
11199 "tableName" | "table_name" => Ok(GeneratedField::TableName),
11200 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11201 }
11202 }
11203 }
11204 deserializer.deserialize_identifier(GeneratedVisitor)
11205 }
11206 }
11207 struct GeneratedVisitor;
11208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11209 type Value = GetTableRequest;
11210
11211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11212 formatter.write_str("struct ddl_service.GetTableRequest")
11213 }
11214
11215 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
11216 where
11217 V: serde::de::MapAccess<'de>,
11218 {
11219 let mut database_name__ = None;
11220 let mut table_name__ = None;
11221 while let Some(k) = map_.next_key()? {
11222 match k {
11223 GeneratedField::DatabaseName => {
11224 if database_name__.is_some() {
11225 return Err(serde::de::Error::duplicate_field("databaseName"));
11226 }
11227 database_name__ = Some(map_.next_value()?);
11228 }
11229 GeneratedField::TableName => {
11230 if table_name__.is_some() {
11231 return Err(serde::de::Error::duplicate_field("tableName"));
11232 }
11233 table_name__ = Some(map_.next_value()?);
11234 }
11235 }
11236 }
11237 Ok(GetTableRequest {
11238 database_name: database_name__.unwrap_or_default(),
11239 table_name: table_name__.unwrap_or_default(),
11240 })
11241 }
11242 }
11243 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
11244 }
11245}
11246impl serde::Serialize for GetTableResponse {
11247 #[allow(deprecated)]
11248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11249 where
11250 S: serde::Serializer,
11251 {
11252 use serde::ser::SerializeStruct;
11253 let mut len = 0;
11254 if self.table.is_some() {
11255 len += 1;
11256 }
11257 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
11258 if let Some(v) = self.table.as_ref() {
11259 struct_ser.serialize_field("table", v)?;
11260 }
11261 struct_ser.end()
11262 }
11263}
11264impl<'de> serde::Deserialize<'de> for GetTableResponse {
11265 #[allow(deprecated)]
11266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11267 where
11268 D: serde::Deserializer<'de>,
11269 {
11270 const FIELDS: &[&str] = &[
11271 "table",
11272 ];
11273
11274 #[allow(clippy::enum_variant_names)]
11275 enum GeneratedField {
11276 Table,
11277 }
11278 impl<'de> serde::Deserialize<'de> for GeneratedField {
11279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11280 where
11281 D: serde::Deserializer<'de>,
11282 {
11283 struct GeneratedVisitor;
11284
11285 impl serde::de::Visitor<'_> for GeneratedVisitor {
11286 type Value = GeneratedField;
11287
11288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11289 write!(formatter, "expected one of: {:?}", &FIELDS)
11290 }
11291
11292 #[allow(unused_variables)]
11293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11294 where
11295 E: serde::de::Error,
11296 {
11297 match value {
11298 "table" => Ok(GeneratedField::Table),
11299 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11300 }
11301 }
11302 }
11303 deserializer.deserialize_identifier(GeneratedVisitor)
11304 }
11305 }
11306 struct GeneratedVisitor;
11307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11308 type Value = GetTableResponse;
11309
11310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11311 formatter.write_str("struct ddl_service.GetTableResponse")
11312 }
11313
11314 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
11315 where
11316 V: serde::de::MapAccess<'de>,
11317 {
11318 let mut table__ = None;
11319 while let Some(k) = map_.next_key()? {
11320 match k {
11321 GeneratedField::Table => {
11322 if table__.is_some() {
11323 return Err(serde::de::Error::duplicate_field("table"));
11324 }
11325 table__ = map_.next_value()?;
11326 }
11327 }
11328 }
11329 Ok(GetTableResponse {
11330 table: table__,
11331 })
11332 }
11333 }
11334 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
11335 }
11336}
11337impl serde::Serialize for GetTablesRequest {
11338 #[allow(deprecated)]
11339 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11340 where
11341 S: serde::Serializer,
11342 {
11343 use serde::ser::SerializeStruct;
11344 let mut len = 0;
11345 if !self.table_ids.is_empty() {
11346 len += 1;
11347 }
11348 if self.include_dropped_tables {
11349 len += 1;
11350 }
11351 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
11352 if !self.table_ids.is_empty() {
11353 struct_ser.serialize_field("tableIds", &self.table_ids)?;
11354 }
11355 if self.include_dropped_tables {
11356 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
11357 }
11358 struct_ser.end()
11359 }
11360}
11361impl<'de> serde::Deserialize<'de> for GetTablesRequest {
11362 #[allow(deprecated)]
11363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11364 where
11365 D: serde::Deserializer<'de>,
11366 {
11367 const FIELDS: &[&str] = &[
11368 "table_ids",
11369 "tableIds",
11370 "include_dropped_tables",
11371 "includeDroppedTables",
11372 ];
11373
11374 #[allow(clippy::enum_variant_names)]
11375 enum GeneratedField {
11376 TableIds,
11377 IncludeDroppedTables,
11378 }
11379 impl<'de> serde::Deserialize<'de> for GeneratedField {
11380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11381 where
11382 D: serde::Deserializer<'de>,
11383 {
11384 struct GeneratedVisitor;
11385
11386 impl serde::de::Visitor<'_> for GeneratedVisitor {
11387 type Value = GeneratedField;
11388
11389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11390 write!(formatter, "expected one of: {:?}", &FIELDS)
11391 }
11392
11393 #[allow(unused_variables)]
11394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11395 where
11396 E: serde::de::Error,
11397 {
11398 match value {
11399 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
11400 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
11401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11402 }
11403 }
11404 }
11405 deserializer.deserialize_identifier(GeneratedVisitor)
11406 }
11407 }
11408 struct GeneratedVisitor;
11409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11410 type Value = GetTablesRequest;
11411
11412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11413 formatter.write_str("struct ddl_service.GetTablesRequest")
11414 }
11415
11416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
11417 where
11418 V: serde::de::MapAccess<'de>,
11419 {
11420 let mut table_ids__ = None;
11421 let mut include_dropped_tables__ = None;
11422 while let Some(k) = map_.next_key()? {
11423 match k {
11424 GeneratedField::TableIds => {
11425 if table_ids__.is_some() {
11426 return Err(serde::de::Error::duplicate_field("tableIds"));
11427 }
11428 table_ids__ =
11429 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11430 .into_iter().map(|x| x.0).collect())
11431 ;
11432 }
11433 GeneratedField::IncludeDroppedTables => {
11434 if include_dropped_tables__.is_some() {
11435 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
11436 }
11437 include_dropped_tables__ = Some(map_.next_value()?);
11438 }
11439 }
11440 }
11441 Ok(GetTablesRequest {
11442 table_ids: table_ids__.unwrap_or_default(),
11443 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
11444 })
11445 }
11446 }
11447 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
11448 }
11449}
11450impl serde::Serialize for GetTablesResponse {
11451 #[allow(deprecated)]
11452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11453 where
11454 S: serde::Serializer,
11455 {
11456 use serde::ser::SerializeStruct;
11457 let mut len = 0;
11458 if !self.tables.is_empty() {
11459 len += 1;
11460 }
11461 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
11462 if !self.tables.is_empty() {
11463 struct_ser.serialize_field("tables", &self.tables)?;
11464 }
11465 struct_ser.end()
11466 }
11467}
11468impl<'de> serde::Deserialize<'de> for GetTablesResponse {
11469 #[allow(deprecated)]
11470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11471 where
11472 D: serde::Deserializer<'de>,
11473 {
11474 const FIELDS: &[&str] = &[
11475 "tables",
11476 ];
11477
11478 #[allow(clippy::enum_variant_names)]
11479 enum GeneratedField {
11480 Tables,
11481 }
11482 impl<'de> serde::Deserialize<'de> for GeneratedField {
11483 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11484 where
11485 D: serde::Deserializer<'de>,
11486 {
11487 struct GeneratedVisitor;
11488
11489 impl serde::de::Visitor<'_> for GeneratedVisitor {
11490 type Value = GeneratedField;
11491
11492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11493 write!(formatter, "expected one of: {:?}", &FIELDS)
11494 }
11495
11496 #[allow(unused_variables)]
11497 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11498 where
11499 E: serde::de::Error,
11500 {
11501 match value {
11502 "tables" => Ok(GeneratedField::Tables),
11503 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11504 }
11505 }
11506 }
11507 deserializer.deserialize_identifier(GeneratedVisitor)
11508 }
11509 }
11510 struct GeneratedVisitor;
11511 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11512 type Value = GetTablesResponse;
11513
11514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11515 formatter.write_str("struct ddl_service.GetTablesResponse")
11516 }
11517
11518 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
11519 where
11520 V: serde::de::MapAccess<'de>,
11521 {
11522 let mut tables__ = None;
11523 while let Some(k) = map_.next_key()? {
11524 match k {
11525 GeneratedField::Tables => {
11526 if tables__.is_some() {
11527 return Err(serde::de::Error::duplicate_field("tables"));
11528 }
11529 tables__ = Some(
11530 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11531 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11532 );
11533 }
11534 }
11535 }
11536 Ok(GetTablesResponse {
11537 tables: tables__.unwrap_or_default(),
11538 })
11539 }
11540 }
11541 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
11542 }
11543}
11544impl serde::Serialize for ListConnectionsRequest {
11545 #[allow(deprecated)]
11546 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11547 where
11548 S: serde::Serializer,
11549 {
11550 use serde::ser::SerializeStruct;
11551 let len = 0;
11552 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
11553 struct_ser.end()
11554 }
11555}
11556impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
11557 #[allow(deprecated)]
11558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11559 where
11560 D: serde::Deserializer<'de>,
11561 {
11562 const FIELDS: &[&str] = &[
11563 ];
11564
11565 #[allow(clippy::enum_variant_names)]
11566 enum GeneratedField {
11567 }
11568 impl<'de> serde::Deserialize<'de> for GeneratedField {
11569 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11570 where
11571 D: serde::Deserializer<'de>,
11572 {
11573 struct GeneratedVisitor;
11574
11575 impl serde::de::Visitor<'_> for GeneratedVisitor {
11576 type Value = GeneratedField;
11577
11578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11579 write!(formatter, "expected one of: {:?}", &FIELDS)
11580 }
11581
11582 #[allow(unused_variables)]
11583 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11584 where
11585 E: serde::de::Error,
11586 {
11587 Err(serde::de::Error::unknown_field(value, FIELDS))
11588 }
11589 }
11590 deserializer.deserialize_identifier(GeneratedVisitor)
11591 }
11592 }
11593 struct GeneratedVisitor;
11594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11595 type Value = ListConnectionsRequest;
11596
11597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11598 formatter.write_str("struct ddl_service.ListConnectionsRequest")
11599 }
11600
11601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
11602 where
11603 V: serde::de::MapAccess<'de>,
11604 {
11605 while map_.next_key::<GeneratedField>()?.is_some() {
11606 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11607 }
11608 Ok(ListConnectionsRequest {
11609 })
11610 }
11611 }
11612 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
11613 }
11614}
11615impl serde::Serialize for ListConnectionsResponse {
11616 #[allow(deprecated)]
11617 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11618 where
11619 S: serde::Serializer,
11620 {
11621 use serde::ser::SerializeStruct;
11622 let mut len = 0;
11623 if !self.connections.is_empty() {
11624 len += 1;
11625 }
11626 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
11627 if !self.connections.is_empty() {
11628 struct_ser.serialize_field("connections", &self.connections)?;
11629 }
11630 struct_ser.end()
11631 }
11632}
11633impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
11634 #[allow(deprecated)]
11635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11636 where
11637 D: serde::Deserializer<'de>,
11638 {
11639 const FIELDS: &[&str] = &[
11640 "connections",
11641 ];
11642
11643 #[allow(clippy::enum_variant_names)]
11644 enum GeneratedField {
11645 Connections,
11646 }
11647 impl<'de> serde::Deserialize<'de> for GeneratedField {
11648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11649 where
11650 D: serde::Deserializer<'de>,
11651 {
11652 struct GeneratedVisitor;
11653
11654 impl serde::de::Visitor<'_> for GeneratedVisitor {
11655 type Value = GeneratedField;
11656
11657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11658 write!(formatter, "expected one of: {:?}", &FIELDS)
11659 }
11660
11661 #[allow(unused_variables)]
11662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11663 where
11664 E: serde::de::Error,
11665 {
11666 match value {
11667 "connections" => Ok(GeneratedField::Connections),
11668 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11669 }
11670 }
11671 }
11672 deserializer.deserialize_identifier(GeneratedVisitor)
11673 }
11674 }
11675 struct GeneratedVisitor;
11676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11677 type Value = ListConnectionsResponse;
11678
11679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11680 formatter.write_str("struct ddl_service.ListConnectionsResponse")
11681 }
11682
11683 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
11684 where
11685 V: serde::de::MapAccess<'de>,
11686 {
11687 let mut connections__ = None;
11688 while let Some(k) = map_.next_key()? {
11689 match k {
11690 GeneratedField::Connections => {
11691 if connections__.is_some() {
11692 return Err(serde::de::Error::duplicate_field("connections"));
11693 }
11694 connections__ = Some(map_.next_value()?);
11695 }
11696 }
11697 }
11698 Ok(ListConnectionsResponse {
11699 connections: connections__.unwrap_or_default(),
11700 })
11701 }
11702 }
11703 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
11704 }
11705}
11706impl serde::Serialize for ReplaceJobPlan {
11707 #[allow(deprecated)]
11708 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11709 where
11710 S: serde::Serializer,
11711 {
11712 use serde::ser::SerializeStruct;
11713 let mut len = 0;
11714 if self.fragment_graph.is_some() {
11715 len += 1;
11716 }
11717 if self.replace_job.is_some() {
11718 len += 1;
11719 }
11720 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
11721 if let Some(v) = self.fragment_graph.as_ref() {
11722 struct_ser.serialize_field("fragmentGraph", v)?;
11723 }
11724 if let Some(v) = self.replace_job.as_ref() {
11725 match v {
11726 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
11727 struct_ser.serialize_field("replaceTable", v)?;
11728 }
11729 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
11730 struct_ser.serialize_field("replaceSource", v)?;
11731 }
11732 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
11733 struct_ser.serialize_field("replaceMaterializedView", v)?;
11734 }
11735 }
11736 }
11737 struct_ser.end()
11738 }
11739}
11740impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
11741 #[allow(deprecated)]
11742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11743 where
11744 D: serde::Deserializer<'de>,
11745 {
11746 const FIELDS: &[&str] = &[
11747 "fragment_graph",
11748 "fragmentGraph",
11749 "replace_table",
11750 "replaceTable",
11751 "replace_source",
11752 "replaceSource",
11753 "replace_materialized_view",
11754 "replaceMaterializedView",
11755 ];
11756
11757 #[allow(clippy::enum_variant_names)]
11758 enum GeneratedField {
11759 FragmentGraph,
11760 ReplaceTable,
11761 ReplaceSource,
11762 ReplaceMaterializedView,
11763 }
11764 impl<'de> serde::Deserialize<'de> for GeneratedField {
11765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11766 where
11767 D: serde::Deserializer<'de>,
11768 {
11769 struct GeneratedVisitor;
11770
11771 impl serde::de::Visitor<'_> for GeneratedVisitor {
11772 type Value = GeneratedField;
11773
11774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11775 write!(formatter, "expected one of: {:?}", &FIELDS)
11776 }
11777
11778 #[allow(unused_variables)]
11779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11780 where
11781 E: serde::de::Error,
11782 {
11783 match value {
11784 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
11785 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
11786 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
11787 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
11788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11789 }
11790 }
11791 }
11792 deserializer.deserialize_identifier(GeneratedVisitor)
11793 }
11794 }
11795 struct GeneratedVisitor;
11796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11797 type Value = ReplaceJobPlan;
11798
11799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11800 formatter.write_str("struct ddl_service.ReplaceJobPlan")
11801 }
11802
11803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
11804 where
11805 V: serde::de::MapAccess<'de>,
11806 {
11807 let mut fragment_graph__ = None;
11808 let mut replace_job__ = None;
11809 while let Some(k) = map_.next_key()? {
11810 match k {
11811 GeneratedField::FragmentGraph => {
11812 if fragment_graph__.is_some() {
11813 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11814 }
11815 fragment_graph__ = map_.next_value()?;
11816 }
11817 GeneratedField::ReplaceTable => {
11818 if replace_job__.is_some() {
11819 return Err(serde::de::Error::duplicate_field("replaceTable"));
11820 }
11821 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11822;
11823 }
11824 GeneratedField::ReplaceSource => {
11825 if replace_job__.is_some() {
11826 return Err(serde::de::Error::duplicate_field("replaceSource"));
11827 }
11828 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11829;
11830 }
11831 GeneratedField::ReplaceMaterializedView => {
11832 if replace_job__.is_some() {
11833 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11834 }
11835 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11836;
11837 }
11838 }
11839 }
11840 Ok(ReplaceJobPlan {
11841 fragment_graph: fragment_graph__,
11842 replace_job: replace_job__,
11843 })
11844 }
11845 }
11846 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11847 }
11848}
11849impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
11850 #[allow(deprecated)]
11851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11852 where
11853 S: serde::Serializer,
11854 {
11855 use serde::ser::SerializeStruct;
11856 let mut len = 0;
11857 if self.table.is_some() {
11858 len += 1;
11859 }
11860 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11861 if let Some(v) = self.table.as_ref() {
11862 struct_ser.serialize_field("table", v)?;
11863 }
11864 struct_ser.end()
11865 }
11866}
11867impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
11868 #[allow(deprecated)]
11869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11870 where
11871 D: serde::Deserializer<'de>,
11872 {
11873 const FIELDS: &[&str] = &[
11874 "table",
11875 ];
11876
11877 #[allow(clippy::enum_variant_names)]
11878 enum GeneratedField {
11879 Table,
11880 }
11881 impl<'de> serde::Deserialize<'de> for GeneratedField {
11882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11883 where
11884 D: serde::Deserializer<'de>,
11885 {
11886 struct GeneratedVisitor;
11887
11888 impl serde::de::Visitor<'_> for GeneratedVisitor {
11889 type Value = GeneratedField;
11890
11891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11892 write!(formatter, "expected one of: {:?}", &FIELDS)
11893 }
11894
11895 #[allow(unused_variables)]
11896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11897 where
11898 E: serde::de::Error,
11899 {
11900 match value {
11901 "table" => Ok(GeneratedField::Table),
11902 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11903 }
11904 }
11905 }
11906 deserializer.deserialize_identifier(GeneratedVisitor)
11907 }
11908 }
11909 struct GeneratedVisitor;
11910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11911 type Value = replace_job_plan::ReplaceMaterializedView;
11912
11913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11914 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11915 }
11916
11917 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11918 where
11919 V: serde::de::MapAccess<'de>,
11920 {
11921 let mut table__ = None;
11922 while let Some(k) = map_.next_key()? {
11923 match k {
11924 GeneratedField::Table => {
11925 if table__.is_some() {
11926 return Err(serde::de::Error::duplicate_field("table"));
11927 }
11928 table__ = map_.next_value()?;
11929 }
11930 }
11931 }
11932 Ok(replace_job_plan::ReplaceMaterializedView {
11933 table: table__,
11934 })
11935 }
11936 }
11937 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11938 }
11939}
11940impl serde::Serialize for replace_job_plan::ReplaceSource {
11941 #[allow(deprecated)]
11942 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11943 where
11944 S: serde::Serializer,
11945 {
11946 use serde::ser::SerializeStruct;
11947 let mut len = 0;
11948 if self.source.is_some() {
11949 len += 1;
11950 }
11951 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11952 if let Some(v) = self.source.as_ref() {
11953 struct_ser.serialize_field("source", v)?;
11954 }
11955 struct_ser.end()
11956 }
11957}
11958impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11959 #[allow(deprecated)]
11960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11961 where
11962 D: serde::Deserializer<'de>,
11963 {
11964 const FIELDS: &[&str] = &[
11965 "source",
11966 ];
11967
11968 #[allow(clippy::enum_variant_names)]
11969 enum GeneratedField {
11970 Source,
11971 }
11972 impl<'de> serde::Deserialize<'de> for GeneratedField {
11973 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11974 where
11975 D: serde::Deserializer<'de>,
11976 {
11977 struct GeneratedVisitor;
11978
11979 impl serde::de::Visitor<'_> for GeneratedVisitor {
11980 type Value = GeneratedField;
11981
11982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11983 write!(formatter, "expected one of: {:?}", &FIELDS)
11984 }
11985
11986 #[allow(unused_variables)]
11987 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11988 where
11989 E: serde::de::Error,
11990 {
11991 match value {
11992 "source" => Ok(GeneratedField::Source),
11993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11994 }
11995 }
11996 }
11997 deserializer.deserialize_identifier(GeneratedVisitor)
11998 }
11999 }
12000 struct GeneratedVisitor;
12001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12002 type Value = replace_job_plan::ReplaceSource;
12003
12004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12005 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
12006 }
12007
12008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
12009 where
12010 V: serde::de::MapAccess<'de>,
12011 {
12012 let mut source__ = None;
12013 while let Some(k) = map_.next_key()? {
12014 match k {
12015 GeneratedField::Source => {
12016 if source__.is_some() {
12017 return Err(serde::de::Error::duplicate_field("source"));
12018 }
12019 source__ = map_.next_value()?;
12020 }
12021 }
12022 }
12023 Ok(replace_job_plan::ReplaceSource {
12024 source: source__,
12025 })
12026 }
12027 }
12028 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
12029 }
12030}
12031impl serde::Serialize for replace_job_plan::ReplaceTable {
12032 #[allow(deprecated)]
12033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12034 where
12035 S: serde::Serializer,
12036 {
12037 use serde::ser::SerializeStruct;
12038 let mut len = 0;
12039 if self.table.is_some() {
12040 len += 1;
12041 }
12042 if self.source.is_some() {
12043 len += 1;
12044 }
12045 if self.job_type != 0 {
12046 len += 1;
12047 }
12048 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
12049 if let Some(v) = self.table.as_ref() {
12050 struct_ser.serialize_field("table", v)?;
12051 }
12052 if let Some(v) = self.source.as_ref() {
12053 struct_ser.serialize_field("source", v)?;
12054 }
12055 if self.job_type != 0 {
12056 let v = TableJobType::try_from(self.job_type)
12057 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
12058 struct_ser.serialize_field("jobType", &v)?;
12059 }
12060 struct_ser.end()
12061 }
12062}
12063impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
12064 #[allow(deprecated)]
12065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12066 where
12067 D: serde::Deserializer<'de>,
12068 {
12069 const FIELDS: &[&str] = &[
12070 "table",
12071 "source",
12072 "job_type",
12073 "jobType",
12074 ];
12075
12076 #[allow(clippy::enum_variant_names)]
12077 enum GeneratedField {
12078 Table,
12079 Source,
12080 JobType,
12081 }
12082 impl<'de> serde::Deserialize<'de> for GeneratedField {
12083 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12084 where
12085 D: serde::Deserializer<'de>,
12086 {
12087 struct GeneratedVisitor;
12088
12089 impl serde::de::Visitor<'_> for GeneratedVisitor {
12090 type Value = GeneratedField;
12091
12092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12093 write!(formatter, "expected one of: {:?}", &FIELDS)
12094 }
12095
12096 #[allow(unused_variables)]
12097 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12098 where
12099 E: serde::de::Error,
12100 {
12101 match value {
12102 "table" => Ok(GeneratedField::Table),
12103 "source" => Ok(GeneratedField::Source),
12104 "jobType" | "job_type" => Ok(GeneratedField::JobType),
12105 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12106 }
12107 }
12108 }
12109 deserializer.deserialize_identifier(GeneratedVisitor)
12110 }
12111 }
12112 struct GeneratedVisitor;
12113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12114 type Value = replace_job_plan::ReplaceTable;
12115
12116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12117 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
12118 }
12119
12120 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
12121 where
12122 V: serde::de::MapAccess<'de>,
12123 {
12124 let mut table__ = None;
12125 let mut source__ = None;
12126 let mut job_type__ = None;
12127 while let Some(k) = map_.next_key()? {
12128 match k {
12129 GeneratedField::Table => {
12130 if table__.is_some() {
12131 return Err(serde::de::Error::duplicate_field("table"));
12132 }
12133 table__ = map_.next_value()?;
12134 }
12135 GeneratedField::Source => {
12136 if source__.is_some() {
12137 return Err(serde::de::Error::duplicate_field("source"));
12138 }
12139 source__ = map_.next_value()?;
12140 }
12141 GeneratedField::JobType => {
12142 if job_type__.is_some() {
12143 return Err(serde::de::Error::duplicate_field("jobType"));
12144 }
12145 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
12146 }
12147 }
12148 }
12149 Ok(replace_job_plan::ReplaceTable {
12150 table: table__,
12151 source: source__,
12152 job_type: job_type__.unwrap_or_default(),
12153 })
12154 }
12155 }
12156 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
12157 }
12158}
12159impl serde::Serialize for ReplaceJobPlanRequest {
12160 #[allow(deprecated)]
12161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12162 where
12163 S: serde::Serializer,
12164 {
12165 use serde::ser::SerializeStruct;
12166 let mut len = 0;
12167 if self.plan.is_some() {
12168 len += 1;
12169 }
12170 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
12171 if let Some(v) = self.plan.as_ref() {
12172 struct_ser.serialize_field("plan", v)?;
12173 }
12174 struct_ser.end()
12175 }
12176}
12177impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
12178 #[allow(deprecated)]
12179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12180 where
12181 D: serde::Deserializer<'de>,
12182 {
12183 const FIELDS: &[&str] = &[
12184 "plan",
12185 ];
12186
12187 #[allow(clippy::enum_variant_names)]
12188 enum GeneratedField {
12189 Plan,
12190 }
12191 impl<'de> serde::Deserialize<'de> for GeneratedField {
12192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12193 where
12194 D: serde::Deserializer<'de>,
12195 {
12196 struct GeneratedVisitor;
12197
12198 impl serde::de::Visitor<'_> for GeneratedVisitor {
12199 type Value = GeneratedField;
12200
12201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12202 write!(formatter, "expected one of: {:?}", &FIELDS)
12203 }
12204
12205 #[allow(unused_variables)]
12206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12207 where
12208 E: serde::de::Error,
12209 {
12210 match value {
12211 "plan" => Ok(GeneratedField::Plan),
12212 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12213 }
12214 }
12215 }
12216 deserializer.deserialize_identifier(GeneratedVisitor)
12217 }
12218 }
12219 struct GeneratedVisitor;
12220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12221 type Value = ReplaceJobPlanRequest;
12222
12223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12224 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
12225 }
12226
12227 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
12228 where
12229 V: serde::de::MapAccess<'de>,
12230 {
12231 let mut plan__ = None;
12232 while let Some(k) = map_.next_key()? {
12233 match k {
12234 GeneratedField::Plan => {
12235 if plan__.is_some() {
12236 return Err(serde::de::Error::duplicate_field("plan"));
12237 }
12238 plan__ = map_.next_value()?;
12239 }
12240 }
12241 }
12242 Ok(ReplaceJobPlanRequest {
12243 plan: plan__,
12244 })
12245 }
12246 }
12247 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
12248 }
12249}
12250impl serde::Serialize for ReplaceJobPlanResponse {
12251 #[allow(deprecated)]
12252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12253 where
12254 S: serde::Serializer,
12255 {
12256 use serde::ser::SerializeStruct;
12257 let mut len = 0;
12258 if self.status.is_some() {
12259 len += 1;
12260 }
12261 if self.version.is_some() {
12262 len += 1;
12263 }
12264 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
12265 if let Some(v) = self.status.as_ref() {
12266 struct_ser.serialize_field("status", v)?;
12267 }
12268 if let Some(v) = self.version.as_ref() {
12269 struct_ser.serialize_field("version", v)?;
12270 }
12271 struct_ser.end()
12272 }
12273}
12274impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
12275 #[allow(deprecated)]
12276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12277 where
12278 D: serde::Deserializer<'de>,
12279 {
12280 const FIELDS: &[&str] = &[
12281 "status",
12282 "version",
12283 ];
12284
12285 #[allow(clippy::enum_variant_names)]
12286 enum GeneratedField {
12287 Status,
12288 Version,
12289 }
12290 impl<'de> serde::Deserialize<'de> for GeneratedField {
12291 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12292 where
12293 D: serde::Deserializer<'de>,
12294 {
12295 struct GeneratedVisitor;
12296
12297 impl serde::de::Visitor<'_> for GeneratedVisitor {
12298 type Value = GeneratedField;
12299
12300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12301 write!(formatter, "expected one of: {:?}", &FIELDS)
12302 }
12303
12304 #[allow(unused_variables)]
12305 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12306 where
12307 E: serde::de::Error,
12308 {
12309 match value {
12310 "status" => Ok(GeneratedField::Status),
12311 "version" => Ok(GeneratedField::Version),
12312 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12313 }
12314 }
12315 }
12316 deserializer.deserialize_identifier(GeneratedVisitor)
12317 }
12318 }
12319 struct GeneratedVisitor;
12320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12321 type Value = ReplaceJobPlanResponse;
12322
12323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12324 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
12325 }
12326
12327 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
12328 where
12329 V: serde::de::MapAccess<'de>,
12330 {
12331 let mut status__ = None;
12332 let mut version__ = None;
12333 while let Some(k) = map_.next_key()? {
12334 match k {
12335 GeneratedField::Status => {
12336 if status__.is_some() {
12337 return Err(serde::de::Error::duplicate_field("status"));
12338 }
12339 status__ = map_.next_value()?;
12340 }
12341 GeneratedField::Version => {
12342 if version__.is_some() {
12343 return Err(serde::de::Error::duplicate_field("version"));
12344 }
12345 version__ = map_.next_value()?;
12346 }
12347 }
12348 }
12349 Ok(ReplaceJobPlanResponse {
12350 status: status__,
12351 version: version__,
12352 })
12353 }
12354 }
12355 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
12356 }
12357}
12358impl serde::Serialize for ResetSourceRequest {
12359 #[allow(deprecated)]
12360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12361 where
12362 S: serde::Serializer,
12363 {
12364 use serde::ser::SerializeStruct;
12365 let mut len = 0;
12366 if self.source_id != 0 {
12367 len += 1;
12368 }
12369 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
12370 if self.source_id != 0 {
12371 struct_ser.serialize_field("sourceId", &self.source_id)?;
12372 }
12373 struct_ser.end()
12374 }
12375}
12376impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
12377 #[allow(deprecated)]
12378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12379 where
12380 D: serde::Deserializer<'de>,
12381 {
12382 const FIELDS: &[&str] = &[
12383 "source_id",
12384 "sourceId",
12385 ];
12386
12387 #[allow(clippy::enum_variant_names)]
12388 enum GeneratedField {
12389 SourceId,
12390 }
12391 impl<'de> serde::Deserialize<'de> for GeneratedField {
12392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12393 where
12394 D: serde::Deserializer<'de>,
12395 {
12396 struct GeneratedVisitor;
12397
12398 impl serde::de::Visitor<'_> for GeneratedVisitor {
12399 type Value = GeneratedField;
12400
12401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12402 write!(formatter, "expected one of: {:?}", &FIELDS)
12403 }
12404
12405 #[allow(unused_variables)]
12406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12407 where
12408 E: serde::de::Error,
12409 {
12410 match value {
12411 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12413 }
12414 }
12415 }
12416 deserializer.deserialize_identifier(GeneratedVisitor)
12417 }
12418 }
12419 struct GeneratedVisitor;
12420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12421 type Value = ResetSourceRequest;
12422
12423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12424 formatter.write_str("struct ddl_service.ResetSourceRequest")
12425 }
12426
12427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
12428 where
12429 V: serde::de::MapAccess<'de>,
12430 {
12431 let mut source_id__ = None;
12432 while let Some(k) = map_.next_key()? {
12433 match k {
12434 GeneratedField::SourceId => {
12435 if source_id__.is_some() {
12436 return Err(serde::de::Error::duplicate_field("sourceId"));
12437 }
12438 source_id__ =
12439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12440 ;
12441 }
12442 }
12443 }
12444 Ok(ResetSourceRequest {
12445 source_id: source_id__.unwrap_or_default(),
12446 })
12447 }
12448 }
12449 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
12450 }
12451}
12452impl serde::Serialize for ResetSourceResponse {
12453 #[allow(deprecated)]
12454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12455 where
12456 S: serde::Serializer,
12457 {
12458 use serde::ser::SerializeStruct;
12459 let mut len = 0;
12460 if self.status.is_some() {
12461 len += 1;
12462 }
12463 if self.version.is_some() {
12464 len += 1;
12465 }
12466 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
12467 if let Some(v) = self.status.as_ref() {
12468 struct_ser.serialize_field("status", v)?;
12469 }
12470 if let Some(v) = self.version.as_ref() {
12471 struct_ser.serialize_field("version", v)?;
12472 }
12473 struct_ser.end()
12474 }
12475}
12476impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
12477 #[allow(deprecated)]
12478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12479 where
12480 D: serde::Deserializer<'de>,
12481 {
12482 const FIELDS: &[&str] = &[
12483 "status",
12484 "version",
12485 ];
12486
12487 #[allow(clippy::enum_variant_names)]
12488 enum GeneratedField {
12489 Status,
12490 Version,
12491 }
12492 impl<'de> serde::Deserialize<'de> for GeneratedField {
12493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12494 where
12495 D: serde::Deserializer<'de>,
12496 {
12497 struct GeneratedVisitor;
12498
12499 impl serde::de::Visitor<'_> for GeneratedVisitor {
12500 type Value = GeneratedField;
12501
12502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12503 write!(formatter, "expected one of: {:?}", &FIELDS)
12504 }
12505
12506 #[allow(unused_variables)]
12507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12508 where
12509 E: serde::de::Error,
12510 {
12511 match value {
12512 "status" => Ok(GeneratedField::Status),
12513 "version" => Ok(GeneratedField::Version),
12514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12515 }
12516 }
12517 }
12518 deserializer.deserialize_identifier(GeneratedVisitor)
12519 }
12520 }
12521 struct GeneratedVisitor;
12522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12523 type Value = ResetSourceResponse;
12524
12525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12526 formatter.write_str("struct ddl_service.ResetSourceResponse")
12527 }
12528
12529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
12530 where
12531 V: serde::de::MapAccess<'de>,
12532 {
12533 let mut status__ = None;
12534 let mut version__ = None;
12535 while let Some(k) = map_.next_key()? {
12536 match k {
12537 GeneratedField::Status => {
12538 if status__.is_some() {
12539 return Err(serde::de::Error::duplicate_field("status"));
12540 }
12541 status__ = map_.next_value()?;
12542 }
12543 GeneratedField::Version => {
12544 if version__.is_some() {
12545 return Err(serde::de::Error::duplicate_field("version"));
12546 }
12547 version__ = map_.next_value()?;
12548 }
12549 }
12550 }
12551 Ok(ResetSourceResponse {
12552 status: status__,
12553 version: version__,
12554 })
12555 }
12556 }
12557 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
12558 }
12559}
12560impl serde::Serialize for RisectlListStateTablesRequest {
12561 #[allow(deprecated)]
12562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12563 where
12564 S: serde::Serializer,
12565 {
12566 use serde::ser::SerializeStruct;
12567 let len = 0;
12568 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
12569 struct_ser.end()
12570 }
12571}
12572impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
12573 #[allow(deprecated)]
12574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12575 where
12576 D: serde::Deserializer<'de>,
12577 {
12578 const FIELDS: &[&str] = &[
12579 ];
12580
12581 #[allow(clippy::enum_variant_names)]
12582 enum GeneratedField {
12583 }
12584 impl<'de> serde::Deserialize<'de> for GeneratedField {
12585 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12586 where
12587 D: serde::Deserializer<'de>,
12588 {
12589 struct GeneratedVisitor;
12590
12591 impl serde::de::Visitor<'_> for GeneratedVisitor {
12592 type Value = GeneratedField;
12593
12594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12595 write!(formatter, "expected one of: {:?}", &FIELDS)
12596 }
12597
12598 #[allow(unused_variables)]
12599 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12600 where
12601 E: serde::de::Error,
12602 {
12603 Err(serde::de::Error::unknown_field(value, FIELDS))
12604 }
12605 }
12606 deserializer.deserialize_identifier(GeneratedVisitor)
12607 }
12608 }
12609 struct GeneratedVisitor;
12610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12611 type Value = RisectlListStateTablesRequest;
12612
12613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12614 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
12615 }
12616
12617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
12618 where
12619 V: serde::de::MapAccess<'de>,
12620 {
12621 while map_.next_key::<GeneratedField>()?.is_some() {
12622 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12623 }
12624 Ok(RisectlListStateTablesRequest {
12625 })
12626 }
12627 }
12628 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
12629 }
12630}
12631impl serde::Serialize for RisectlListStateTablesResponse {
12632 #[allow(deprecated)]
12633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12634 where
12635 S: serde::Serializer,
12636 {
12637 use serde::ser::SerializeStruct;
12638 let mut len = 0;
12639 if !self.tables.is_empty() {
12640 len += 1;
12641 }
12642 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
12643 if !self.tables.is_empty() {
12644 struct_ser.serialize_field("tables", &self.tables)?;
12645 }
12646 struct_ser.end()
12647 }
12648}
12649impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
12650 #[allow(deprecated)]
12651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12652 where
12653 D: serde::Deserializer<'de>,
12654 {
12655 const FIELDS: &[&str] = &[
12656 "tables",
12657 ];
12658
12659 #[allow(clippy::enum_variant_names)]
12660 enum GeneratedField {
12661 Tables,
12662 }
12663 impl<'de> serde::Deserialize<'de> for GeneratedField {
12664 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12665 where
12666 D: serde::Deserializer<'de>,
12667 {
12668 struct GeneratedVisitor;
12669
12670 impl serde::de::Visitor<'_> for GeneratedVisitor {
12671 type Value = GeneratedField;
12672
12673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12674 write!(formatter, "expected one of: {:?}", &FIELDS)
12675 }
12676
12677 #[allow(unused_variables)]
12678 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12679 where
12680 E: serde::de::Error,
12681 {
12682 match value {
12683 "tables" => Ok(GeneratedField::Tables),
12684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12685 }
12686 }
12687 }
12688 deserializer.deserialize_identifier(GeneratedVisitor)
12689 }
12690 }
12691 struct GeneratedVisitor;
12692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12693 type Value = RisectlListStateTablesResponse;
12694
12695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12696 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
12697 }
12698
12699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
12700 where
12701 V: serde::de::MapAccess<'de>,
12702 {
12703 let mut tables__ = None;
12704 while let Some(k) = map_.next_key()? {
12705 match k {
12706 GeneratedField::Tables => {
12707 if tables__.is_some() {
12708 return Err(serde::de::Error::duplicate_field("tables"));
12709 }
12710 tables__ = Some(map_.next_value()?);
12711 }
12712 }
12713 }
12714 Ok(RisectlListStateTablesResponse {
12715 tables: tables__.unwrap_or_default(),
12716 })
12717 }
12718 }
12719 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
12720 }
12721}
12722impl serde::Serialize for RisectlResumeBackfillRequest {
12723 #[allow(deprecated)]
12724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12725 where
12726 S: serde::Serializer,
12727 {
12728 use serde::ser::SerializeStruct;
12729 let mut len = 0;
12730 if self.target.is_some() {
12731 len += 1;
12732 }
12733 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillRequest", len)?;
12734 if let Some(v) = self.target.as_ref() {
12735 match v {
12736 risectl_resume_backfill_request::Target::JobId(v) => {
12737 struct_ser.serialize_field("jobId", v)?;
12738 }
12739 risectl_resume_backfill_request::Target::FragmentId(v) => {
12740 struct_ser.serialize_field("fragmentId", v)?;
12741 }
12742 }
12743 }
12744 struct_ser.end()
12745 }
12746}
12747impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillRequest {
12748 #[allow(deprecated)]
12749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12750 where
12751 D: serde::Deserializer<'de>,
12752 {
12753 const FIELDS: &[&str] = &[
12754 "job_id",
12755 "jobId",
12756 "fragment_id",
12757 "fragmentId",
12758 ];
12759
12760 #[allow(clippy::enum_variant_names)]
12761 enum GeneratedField {
12762 JobId,
12763 FragmentId,
12764 }
12765 impl<'de> serde::Deserialize<'de> for GeneratedField {
12766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12767 where
12768 D: serde::Deserializer<'de>,
12769 {
12770 struct GeneratedVisitor;
12771
12772 impl serde::de::Visitor<'_> for GeneratedVisitor {
12773 type Value = GeneratedField;
12774
12775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12776 write!(formatter, "expected one of: {:?}", &FIELDS)
12777 }
12778
12779 #[allow(unused_variables)]
12780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12781 where
12782 E: serde::de::Error,
12783 {
12784 match value {
12785 "jobId" | "job_id" => Ok(GeneratedField::JobId),
12786 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12788 }
12789 }
12790 }
12791 deserializer.deserialize_identifier(GeneratedVisitor)
12792 }
12793 }
12794 struct GeneratedVisitor;
12795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12796 type Value = RisectlResumeBackfillRequest;
12797
12798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12799 formatter.write_str("struct ddl_service.RisectlResumeBackfillRequest")
12800 }
12801
12802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillRequest, V::Error>
12803 where
12804 V: serde::de::MapAccess<'de>,
12805 {
12806 let mut target__ = None;
12807 while let Some(k) = map_.next_key()? {
12808 match k {
12809 GeneratedField::JobId => {
12810 if target__.is_some() {
12811 return Err(serde::de::Error::duplicate_field("jobId"));
12812 }
12813 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::JobId(x.0));
12814 }
12815 GeneratedField::FragmentId => {
12816 if target__.is_some() {
12817 return Err(serde::de::Error::duplicate_field("fragmentId"));
12818 }
12819 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::FragmentId(x.0));
12820 }
12821 }
12822 }
12823 Ok(RisectlResumeBackfillRequest {
12824 target: target__,
12825 })
12826 }
12827 }
12828 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillRequest", FIELDS, GeneratedVisitor)
12829 }
12830}
12831impl serde::Serialize for RisectlResumeBackfillResponse {
12832 #[allow(deprecated)]
12833 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12834 where
12835 S: serde::Serializer,
12836 {
12837 use serde::ser::SerializeStruct;
12838 let len = 0;
12839 let struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillResponse", len)?;
12840 struct_ser.end()
12841 }
12842}
12843impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillResponse {
12844 #[allow(deprecated)]
12845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12846 where
12847 D: serde::Deserializer<'de>,
12848 {
12849 const FIELDS: &[&str] = &[
12850 ];
12851
12852 #[allow(clippy::enum_variant_names)]
12853 enum GeneratedField {
12854 }
12855 impl<'de> serde::Deserialize<'de> for GeneratedField {
12856 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12857 where
12858 D: serde::Deserializer<'de>,
12859 {
12860 struct GeneratedVisitor;
12861
12862 impl serde::de::Visitor<'_> for GeneratedVisitor {
12863 type Value = GeneratedField;
12864
12865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12866 write!(formatter, "expected one of: {:?}", &FIELDS)
12867 }
12868
12869 #[allow(unused_variables)]
12870 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12871 where
12872 E: serde::de::Error,
12873 {
12874 Err(serde::de::Error::unknown_field(value, FIELDS))
12875 }
12876 }
12877 deserializer.deserialize_identifier(GeneratedVisitor)
12878 }
12879 }
12880 struct GeneratedVisitor;
12881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12882 type Value = RisectlResumeBackfillResponse;
12883
12884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12885 formatter.write_str("struct ddl_service.RisectlResumeBackfillResponse")
12886 }
12887
12888 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillResponse, V::Error>
12889 where
12890 V: serde::de::MapAccess<'de>,
12891 {
12892 while map_.next_key::<GeneratedField>()?.is_some() {
12893 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12894 }
12895 Ok(RisectlResumeBackfillResponse {
12896 })
12897 }
12898 }
12899 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillResponse", FIELDS, GeneratedVisitor)
12900 }
12901}
12902impl serde::Serialize for SchemaChangeEnvelope {
12903 #[allow(deprecated)]
12904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12905 where
12906 S: serde::Serializer,
12907 {
12908 use serde::ser::SerializeStruct;
12909 let mut len = 0;
12910 if !self.table_changes.is_empty() {
12911 len += 1;
12912 }
12913 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
12914 if !self.table_changes.is_empty() {
12915 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
12916 }
12917 struct_ser.end()
12918 }
12919}
12920impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
12921 #[allow(deprecated)]
12922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12923 where
12924 D: serde::Deserializer<'de>,
12925 {
12926 const FIELDS: &[&str] = &[
12927 "table_changes",
12928 "tableChanges",
12929 ];
12930
12931 #[allow(clippy::enum_variant_names)]
12932 enum GeneratedField {
12933 TableChanges,
12934 }
12935 impl<'de> serde::Deserialize<'de> for GeneratedField {
12936 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12937 where
12938 D: serde::Deserializer<'de>,
12939 {
12940 struct GeneratedVisitor;
12941
12942 impl serde::de::Visitor<'_> for GeneratedVisitor {
12943 type Value = GeneratedField;
12944
12945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12946 write!(formatter, "expected one of: {:?}", &FIELDS)
12947 }
12948
12949 #[allow(unused_variables)]
12950 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12951 where
12952 E: serde::de::Error,
12953 {
12954 match value {
12955 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
12956 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12957 }
12958 }
12959 }
12960 deserializer.deserialize_identifier(GeneratedVisitor)
12961 }
12962 }
12963 struct GeneratedVisitor;
12964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12965 type Value = SchemaChangeEnvelope;
12966
12967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12968 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
12969 }
12970
12971 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
12972 where
12973 V: serde::de::MapAccess<'de>,
12974 {
12975 let mut table_changes__ = None;
12976 while let Some(k) = map_.next_key()? {
12977 match k {
12978 GeneratedField::TableChanges => {
12979 if table_changes__.is_some() {
12980 return Err(serde::de::Error::duplicate_field("tableChanges"));
12981 }
12982 table_changes__ = Some(map_.next_value()?);
12983 }
12984 }
12985 }
12986 Ok(SchemaChangeEnvelope {
12987 table_changes: table_changes__.unwrap_or_default(),
12988 })
12989 }
12990 }
12991 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
12992 }
12993}
12994impl serde::Serialize for StreamingJobResourceType {
12995 #[allow(deprecated)]
12996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12997 where
12998 S: serde::Serializer,
12999 {
13000 use serde::ser::SerializeStruct;
13001 let mut len = 0;
13002 if self.resource_type.is_some() {
13003 len += 1;
13004 }
13005 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
13006 if let Some(v) = self.resource_type.as_ref() {
13007 match v {
13008 streaming_job_resource_type::ResourceType::Regular(v) => {
13009 struct_ser.serialize_field("regular", v)?;
13010 }
13011 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
13012 struct_ser.serialize_field("specificResourceGroup", v)?;
13013 }
13014 streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup(v) => {
13015 struct_ser.serialize_field("serverlessBackfillResourceGroup", v)?;
13016 }
13017 }
13018 }
13019 struct_ser.end()
13020 }
13021}
13022impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
13023 #[allow(deprecated)]
13024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13025 where
13026 D: serde::Deserializer<'de>,
13027 {
13028 const FIELDS: &[&str] = &[
13029 "regular",
13030 "specific_resource_group",
13031 "specificResourceGroup",
13032 "serverless_backfill_resource_group",
13033 "serverlessBackfillResourceGroup",
13034 ];
13035
13036 #[allow(clippy::enum_variant_names)]
13037 enum GeneratedField {
13038 Regular,
13039 SpecificResourceGroup,
13040 ServerlessBackfillResourceGroup,
13041 }
13042 impl<'de> serde::Deserialize<'de> for GeneratedField {
13043 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13044 where
13045 D: serde::Deserializer<'de>,
13046 {
13047 struct GeneratedVisitor;
13048
13049 impl serde::de::Visitor<'_> for GeneratedVisitor {
13050 type Value = GeneratedField;
13051
13052 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13053 write!(formatter, "expected one of: {:?}", &FIELDS)
13054 }
13055
13056 #[allow(unused_variables)]
13057 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13058 where
13059 E: serde::de::Error,
13060 {
13061 match value {
13062 "regular" => Ok(GeneratedField::Regular),
13063 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
13064 "serverlessBackfillResourceGroup" | "serverless_backfill_resource_group" => Ok(GeneratedField::ServerlessBackfillResourceGroup),
13065 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13066 }
13067 }
13068 }
13069 deserializer.deserialize_identifier(GeneratedVisitor)
13070 }
13071 }
13072 struct GeneratedVisitor;
13073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13074 type Value = StreamingJobResourceType;
13075
13076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13077 formatter.write_str("struct ddl_service.StreamingJobResourceType")
13078 }
13079
13080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
13081 where
13082 V: serde::de::MapAccess<'de>,
13083 {
13084 let mut resource_type__ = None;
13085 while let Some(k) = map_.next_key()? {
13086 match k {
13087 GeneratedField::Regular => {
13088 if resource_type__.is_some() {
13089 return Err(serde::de::Error::duplicate_field("regular"));
13090 }
13091 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
13092 }
13093 GeneratedField::SpecificResourceGroup => {
13094 if resource_type__.is_some() {
13095 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
13096 }
13097 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
13098 }
13099 GeneratedField::ServerlessBackfillResourceGroup => {
13100 if resource_type__.is_some() {
13101 return Err(serde::de::Error::duplicate_field("serverlessBackfillResourceGroup"));
13102 }
13103 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup);
13104 }
13105 }
13106 }
13107 Ok(StreamingJobResourceType {
13108 resource_type: resource_type__,
13109 })
13110 }
13111 }
13112 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
13113 }
13114}
13115impl serde::Serialize for TableJobType {
13116 #[allow(deprecated)]
13117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13118 where
13119 S: serde::Serializer,
13120 {
13121 let variant = match self {
13122 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
13123 Self::General => "TABLE_JOB_TYPE_GENERAL",
13124 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
13125 };
13126 serializer.serialize_str(variant)
13127 }
13128}
13129impl<'de> serde::Deserialize<'de> for TableJobType {
13130 #[allow(deprecated)]
13131 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13132 where
13133 D: serde::Deserializer<'de>,
13134 {
13135 const FIELDS: &[&str] = &[
13136 "TABLE_JOB_TYPE_UNSPECIFIED",
13137 "TABLE_JOB_TYPE_GENERAL",
13138 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
13139 ];
13140
13141 struct GeneratedVisitor;
13142
13143 impl serde::de::Visitor<'_> for GeneratedVisitor {
13144 type Value = TableJobType;
13145
13146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13147 write!(formatter, "expected one of: {:?}", &FIELDS)
13148 }
13149
13150 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13151 where
13152 E: serde::de::Error,
13153 {
13154 i32::try_from(v)
13155 .ok()
13156 .and_then(|x| x.try_into().ok())
13157 .ok_or_else(|| {
13158 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13159 })
13160 }
13161
13162 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13163 where
13164 E: serde::de::Error,
13165 {
13166 i32::try_from(v)
13167 .ok()
13168 .and_then(|x| x.try_into().ok())
13169 .ok_or_else(|| {
13170 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13171 })
13172 }
13173
13174 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13175 where
13176 E: serde::de::Error,
13177 {
13178 match value {
13179 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
13180 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
13181 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
13182 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13183 }
13184 }
13185 }
13186 deserializer.deserialize_any(GeneratedVisitor)
13187 }
13188}
13189impl serde::Serialize for TableSchemaChange {
13190 #[allow(deprecated)]
13191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13192 where
13193 S: serde::Serializer,
13194 {
13195 use serde::ser::SerializeStruct;
13196 let mut len = 0;
13197 if self.change_type != 0 {
13198 len += 1;
13199 }
13200 if !self.cdc_table_id.is_empty() {
13201 len += 1;
13202 }
13203 if !self.columns.is_empty() {
13204 len += 1;
13205 }
13206 if !self.upstream_ddl.is_empty() {
13207 len += 1;
13208 }
13209 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
13210 if self.change_type != 0 {
13211 let v = table_schema_change::TableChangeType::try_from(self.change_type)
13212 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
13213 struct_ser.serialize_field("changeType", &v)?;
13214 }
13215 if !self.cdc_table_id.is_empty() {
13216 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
13217 }
13218 if !self.columns.is_empty() {
13219 struct_ser.serialize_field("columns", &self.columns)?;
13220 }
13221 if !self.upstream_ddl.is_empty() {
13222 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
13223 }
13224 struct_ser.end()
13225 }
13226}
13227impl<'de> serde::Deserialize<'de> for TableSchemaChange {
13228 #[allow(deprecated)]
13229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13230 where
13231 D: serde::Deserializer<'de>,
13232 {
13233 const FIELDS: &[&str] = &[
13234 "change_type",
13235 "changeType",
13236 "cdc_table_id",
13237 "cdcTableId",
13238 "columns",
13239 "upstream_ddl",
13240 "upstreamDdl",
13241 ];
13242
13243 #[allow(clippy::enum_variant_names)]
13244 enum GeneratedField {
13245 ChangeType,
13246 CdcTableId,
13247 Columns,
13248 UpstreamDdl,
13249 }
13250 impl<'de> serde::Deserialize<'de> for GeneratedField {
13251 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13252 where
13253 D: serde::Deserializer<'de>,
13254 {
13255 struct GeneratedVisitor;
13256
13257 impl serde::de::Visitor<'_> for GeneratedVisitor {
13258 type Value = GeneratedField;
13259
13260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13261 write!(formatter, "expected one of: {:?}", &FIELDS)
13262 }
13263
13264 #[allow(unused_variables)]
13265 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13266 where
13267 E: serde::de::Error,
13268 {
13269 match value {
13270 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
13271 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
13272 "columns" => Ok(GeneratedField::Columns),
13273 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
13274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13275 }
13276 }
13277 }
13278 deserializer.deserialize_identifier(GeneratedVisitor)
13279 }
13280 }
13281 struct GeneratedVisitor;
13282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13283 type Value = TableSchemaChange;
13284
13285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13286 formatter.write_str("struct ddl_service.TableSchemaChange")
13287 }
13288
13289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
13290 where
13291 V: serde::de::MapAccess<'de>,
13292 {
13293 let mut change_type__ = None;
13294 let mut cdc_table_id__ = None;
13295 let mut columns__ = None;
13296 let mut upstream_ddl__ = None;
13297 while let Some(k) = map_.next_key()? {
13298 match k {
13299 GeneratedField::ChangeType => {
13300 if change_type__.is_some() {
13301 return Err(serde::de::Error::duplicate_field("changeType"));
13302 }
13303 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
13304 }
13305 GeneratedField::CdcTableId => {
13306 if cdc_table_id__.is_some() {
13307 return Err(serde::de::Error::duplicate_field("cdcTableId"));
13308 }
13309 cdc_table_id__ = Some(map_.next_value()?);
13310 }
13311 GeneratedField::Columns => {
13312 if columns__.is_some() {
13313 return Err(serde::de::Error::duplicate_field("columns"));
13314 }
13315 columns__ = Some(map_.next_value()?);
13316 }
13317 GeneratedField::UpstreamDdl => {
13318 if upstream_ddl__.is_some() {
13319 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
13320 }
13321 upstream_ddl__ = Some(map_.next_value()?);
13322 }
13323 }
13324 }
13325 Ok(TableSchemaChange {
13326 change_type: change_type__.unwrap_or_default(),
13327 cdc_table_id: cdc_table_id__.unwrap_or_default(),
13328 columns: columns__.unwrap_or_default(),
13329 upstream_ddl: upstream_ddl__.unwrap_or_default(),
13330 })
13331 }
13332 }
13333 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
13334 }
13335}
13336impl serde::Serialize for table_schema_change::TableChangeType {
13337 #[allow(deprecated)]
13338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13339 where
13340 S: serde::Serializer,
13341 {
13342 let variant = match self {
13343 Self::Unspecified => "UNSPECIFIED",
13344 Self::Alter => "ALTER",
13345 Self::Create => "CREATE",
13346 Self::Drop => "DROP",
13347 };
13348 serializer.serialize_str(variant)
13349 }
13350}
13351impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
13352 #[allow(deprecated)]
13353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13354 where
13355 D: serde::Deserializer<'de>,
13356 {
13357 const FIELDS: &[&str] = &[
13358 "UNSPECIFIED",
13359 "ALTER",
13360 "CREATE",
13361 "DROP",
13362 ];
13363
13364 struct GeneratedVisitor;
13365
13366 impl serde::de::Visitor<'_> for GeneratedVisitor {
13367 type Value = table_schema_change::TableChangeType;
13368
13369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13370 write!(formatter, "expected one of: {:?}", &FIELDS)
13371 }
13372
13373 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13374 where
13375 E: serde::de::Error,
13376 {
13377 i32::try_from(v)
13378 .ok()
13379 .and_then(|x| x.try_into().ok())
13380 .ok_or_else(|| {
13381 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13382 })
13383 }
13384
13385 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13386 where
13387 E: serde::de::Error,
13388 {
13389 i32::try_from(v)
13390 .ok()
13391 .and_then(|x| x.try_into().ok())
13392 .ok_or_else(|| {
13393 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13394 })
13395 }
13396
13397 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13398 where
13399 E: serde::de::Error,
13400 {
13401 match value {
13402 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
13403 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
13404 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
13405 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
13406 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13407 }
13408 }
13409 }
13410 deserializer.deserialize_any(GeneratedVisitor)
13411 }
13412}
13413impl serde::Serialize for WaitRequest {
13414 #[allow(deprecated)]
13415 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13416 where
13417 S: serde::Serializer,
13418 {
13419 use serde::ser::SerializeStruct;
13420 let mut len = 0;
13421 if self.job_id.is_some() {
13422 len += 1;
13423 }
13424 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
13425 if let Some(v) = self.job_id.as_ref() {
13426 struct_ser.serialize_field("jobId", v)?;
13427 }
13428 struct_ser.end()
13429 }
13430}
13431impl<'de> serde::Deserialize<'de> for WaitRequest {
13432 #[allow(deprecated)]
13433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13434 where
13435 D: serde::Deserializer<'de>,
13436 {
13437 const FIELDS: &[&str] = &[
13438 "job_id",
13439 "jobId",
13440 ];
13441
13442 #[allow(clippy::enum_variant_names)]
13443 enum GeneratedField {
13444 JobId,
13445 }
13446 impl<'de> serde::Deserialize<'de> for GeneratedField {
13447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13448 where
13449 D: serde::Deserializer<'de>,
13450 {
13451 struct GeneratedVisitor;
13452
13453 impl serde::de::Visitor<'_> for GeneratedVisitor {
13454 type Value = GeneratedField;
13455
13456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13457 write!(formatter, "expected one of: {:?}", &FIELDS)
13458 }
13459
13460 #[allow(unused_variables)]
13461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13462 where
13463 E: serde::de::Error,
13464 {
13465 match value {
13466 "jobId" | "job_id" => Ok(GeneratedField::JobId),
13467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13468 }
13469 }
13470 }
13471 deserializer.deserialize_identifier(GeneratedVisitor)
13472 }
13473 }
13474 struct GeneratedVisitor;
13475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13476 type Value = WaitRequest;
13477
13478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13479 formatter.write_str("struct ddl_service.WaitRequest")
13480 }
13481
13482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
13483 where
13484 V: serde::de::MapAccess<'de>,
13485 {
13486 let mut job_id__ = None;
13487 while let Some(k) = map_.next_key()? {
13488 match k {
13489 GeneratedField::JobId => {
13490 if job_id__.is_some() {
13491 return Err(serde::de::Error::duplicate_field("jobId"));
13492 }
13493 job_id__ =
13494 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13495 ;
13496 }
13497 }
13498 }
13499 Ok(WaitRequest {
13500 job_id: job_id__,
13501 })
13502 }
13503 }
13504 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
13505 }
13506}
13507impl serde::Serialize for WaitResponse {
13508 #[allow(deprecated)]
13509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13510 where
13511 S: serde::Serializer,
13512 {
13513 use serde::ser::SerializeStruct;
13514 let mut len = 0;
13515 if self.version.is_some() {
13516 len += 1;
13517 }
13518 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
13519 if let Some(v) = self.version.as_ref() {
13520 struct_ser.serialize_field("version", v)?;
13521 }
13522 struct_ser.end()
13523 }
13524}
13525impl<'de> serde::Deserialize<'de> for WaitResponse {
13526 #[allow(deprecated)]
13527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13528 where
13529 D: serde::Deserializer<'de>,
13530 {
13531 const FIELDS: &[&str] = &[
13532 "version",
13533 ];
13534
13535 #[allow(clippy::enum_variant_names)]
13536 enum GeneratedField {
13537 Version,
13538 }
13539 impl<'de> serde::Deserialize<'de> for GeneratedField {
13540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13541 where
13542 D: serde::Deserializer<'de>,
13543 {
13544 struct GeneratedVisitor;
13545
13546 impl serde::de::Visitor<'_> for GeneratedVisitor {
13547 type Value = GeneratedField;
13548
13549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13550 write!(formatter, "expected one of: {:?}", &FIELDS)
13551 }
13552
13553 #[allow(unused_variables)]
13554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13555 where
13556 E: serde::de::Error,
13557 {
13558 match value {
13559 "version" => Ok(GeneratedField::Version),
13560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13561 }
13562 }
13563 }
13564 deserializer.deserialize_identifier(GeneratedVisitor)
13565 }
13566 }
13567 struct GeneratedVisitor;
13568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13569 type Value = WaitResponse;
13570
13571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13572 formatter.write_str("struct ddl_service.WaitResponse")
13573 }
13574
13575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
13576 where
13577 V: serde::de::MapAccess<'de>,
13578 {
13579 let mut version__ = None;
13580 while let Some(k) = map_.next_key()? {
13581 match k {
13582 GeneratedField::Version => {
13583 if version__.is_some() {
13584 return Err(serde::de::Error::duplicate_field("version"));
13585 }
13586 version__ = map_.next_value()?;
13587 }
13588 }
13589 }
13590 Ok(WaitResponse {
13591 version: version__,
13592 })
13593 }
13594 }
13595 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
13596 }
13597}
13598impl serde::Serialize for WaitVersion {
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.catalog_version != 0 {
13607 len += 1;
13608 }
13609 if self.hummock_version_id != 0 {
13610 len += 1;
13611 }
13612 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
13613 if self.catalog_version != 0 {
13614 #[allow(clippy::needless_borrow)]
13615 #[allow(clippy::needless_borrows_for_generic_args)]
13616 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
13617 }
13618 if self.hummock_version_id != 0 {
13619 #[allow(clippy::needless_borrow)]
13620 #[allow(clippy::needless_borrows_for_generic_args)]
13621 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
13622 }
13623 struct_ser.end()
13624 }
13625}
13626impl<'de> serde::Deserialize<'de> for WaitVersion {
13627 #[allow(deprecated)]
13628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13629 where
13630 D: serde::Deserializer<'de>,
13631 {
13632 const FIELDS: &[&str] = &[
13633 "catalog_version",
13634 "catalogVersion",
13635 "hummock_version_id",
13636 "hummockVersionId",
13637 ];
13638
13639 #[allow(clippy::enum_variant_names)]
13640 enum GeneratedField {
13641 CatalogVersion,
13642 HummockVersionId,
13643 }
13644 impl<'de> serde::Deserialize<'de> for GeneratedField {
13645 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13646 where
13647 D: serde::Deserializer<'de>,
13648 {
13649 struct GeneratedVisitor;
13650
13651 impl serde::de::Visitor<'_> for GeneratedVisitor {
13652 type Value = GeneratedField;
13653
13654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13655 write!(formatter, "expected one of: {:?}", &FIELDS)
13656 }
13657
13658 #[allow(unused_variables)]
13659 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13660 where
13661 E: serde::de::Error,
13662 {
13663 match value {
13664 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
13665 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
13666 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13667 }
13668 }
13669 }
13670 deserializer.deserialize_identifier(GeneratedVisitor)
13671 }
13672 }
13673 struct GeneratedVisitor;
13674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13675 type Value = WaitVersion;
13676
13677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13678 formatter.write_str("struct ddl_service.WaitVersion")
13679 }
13680
13681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
13682 where
13683 V: serde::de::MapAccess<'de>,
13684 {
13685 let mut catalog_version__ = None;
13686 let mut hummock_version_id__ = None;
13687 while let Some(k) = map_.next_key()? {
13688 match k {
13689 GeneratedField::CatalogVersion => {
13690 if catalog_version__.is_some() {
13691 return Err(serde::de::Error::duplicate_field("catalogVersion"));
13692 }
13693 catalog_version__ =
13694 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13695 ;
13696 }
13697 GeneratedField::HummockVersionId => {
13698 if hummock_version_id__.is_some() {
13699 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
13700 }
13701 hummock_version_id__ =
13702 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13703 ;
13704 }
13705 }
13706 }
13707 Ok(WaitVersion {
13708 catalog_version: catalog_version__.unwrap_or_default(),
13709 hummock_version_id: hummock_version_id__.unwrap_or_default(),
13710 })
13711 }
13712 }
13713 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
13714 }
13715}