1#![allow(clippy::useless_conversion)]
2use crate::ddl_service::*;
3impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.table_id != 0 {
12 len += 1;
13 }
14 if self.parallelism.is_some() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
18 if self.table_id != 0 {
19 struct_ser.serialize_field("tableId", &self.table_id)?;
20 }
21 if let Some(v) = self.parallelism.as_ref() {
22 struct_ser.serialize_field("parallelism", v)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "table_id",
35 "tableId",
36 "parallelism",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 TableId,
42 Parallelism,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl serde::de::Visitor<'_> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "tableId" | "table_id" => Ok(GeneratedField::TableId),
65 "parallelism" => Ok(GeneratedField::Parallelism),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = AlterCdcTableBackfillParallelismRequest;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut table_id__ = None;
86 let mut parallelism__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::TableId => {
90 if table_id__.is_some() {
91 return Err(serde::de::Error::duplicate_field("tableId"));
92 }
93 table_id__ =
94 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
95 ;
96 }
97 GeneratedField::Parallelism => {
98 if parallelism__.is_some() {
99 return Err(serde::de::Error::duplicate_field("parallelism"));
100 }
101 parallelism__ = map_.next_value()?;
102 }
103 }
104 }
105 Ok(AlterCdcTableBackfillParallelismRequest {
106 table_id: table_id__.unwrap_or_default(),
107 parallelism: parallelism__,
108 })
109 }
110 }
111 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
112 }
113}
114impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
115 #[allow(deprecated)]
116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
117 where
118 S: serde::Serializer,
119 {
120 use serde::ser::SerializeStruct;
121 let len = 0;
122 let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
123 struct_ser.end()
124 }
125}
126impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
127 #[allow(deprecated)]
128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
129 where
130 D: serde::Deserializer<'de>,
131 {
132 const FIELDS: &[&str] = &[
133 ];
134
135 #[allow(clippy::enum_variant_names)]
136 enum GeneratedField {
137 }
138 impl<'de> serde::Deserialize<'de> for GeneratedField {
139 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
140 where
141 D: serde::Deserializer<'de>,
142 {
143 struct GeneratedVisitor;
144
145 impl serde::de::Visitor<'_> for GeneratedVisitor {
146 type Value = GeneratedField;
147
148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
149 write!(formatter, "expected one of: {:?}", &FIELDS)
150 }
151
152 #[allow(unused_variables)]
153 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
154 where
155 E: serde::de::Error,
156 {
157 Err(serde::de::Error::unknown_field(value, FIELDS))
158 }
159 }
160 deserializer.deserialize_identifier(GeneratedVisitor)
161 }
162 }
163 struct GeneratedVisitor;
164 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
165 type Value = AlterCdcTableBackfillParallelismResponse;
166
167 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
168 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
169 }
170
171 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
172 where
173 V: serde::de::MapAccess<'de>,
174 {
175 while map_.next_key::<GeneratedField>()?.is_some() {
176 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
177 }
178 Ok(AlterCdcTableBackfillParallelismResponse {
179 })
180 }
181 }
182 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
183 }
184}
185impl serde::Serialize for AlterDatabaseParamRequest {
186 #[allow(deprecated)]
187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
188 where
189 S: serde::Serializer,
190 {
191 use serde::ser::SerializeStruct;
192 let mut len = 0;
193 if self.database_id != 0 {
194 len += 1;
195 }
196 if self.param.is_some() {
197 len += 1;
198 }
199 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
200 if self.database_id != 0 {
201 struct_ser.serialize_field("databaseId", &self.database_id)?;
202 }
203 if let Some(v) = self.param.as_ref() {
204 match v {
205 alter_database_param_request::Param::BarrierIntervalMs(v) => {
206 struct_ser.serialize_field("barrierIntervalMs", v)?;
207 }
208 alter_database_param_request::Param::CheckpointFrequency(v) => {
209 struct_ser.serialize_field("checkpointFrequency", v)?;
210 }
211 }
212 }
213 struct_ser.end()
214 }
215}
216impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
217 #[allow(deprecated)]
218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
219 where
220 D: serde::Deserializer<'de>,
221 {
222 const FIELDS: &[&str] = &[
223 "database_id",
224 "databaseId",
225 "barrier_interval_ms",
226 "barrierIntervalMs",
227 "checkpoint_frequency",
228 "checkpointFrequency",
229 ];
230
231 #[allow(clippy::enum_variant_names)]
232 enum GeneratedField {
233 DatabaseId,
234 BarrierIntervalMs,
235 CheckpointFrequency,
236 }
237 impl<'de> serde::Deserialize<'de> for GeneratedField {
238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
239 where
240 D: serde::Deserializer<'de>,
241 {
242 struct GeneratedVisitor;
243
244 impl serde::de::Visitor<'_> for GeneratedVisitor {
245 type Value = GeneratedField;
246
247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
248 write!(formatter, "expected one of: {:?}", &FIELDS)
249 }
250
251 #[allow(unused_variables)]
252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
253 where
254 E: serde::de::Error,
255 {
256 match value {
257 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
258 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
259 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
261 }
262 }
263 }
264 deserializer.deserialize_identifier(GeneratedVisitor)
265 }
266 }
267 struct GeneratedVisitor;
268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
269 type Value = AlterDatabaseParamRequest;
270
271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
272 formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
273 }
274
275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
276 where
277 V: serde::de::MapAccess<'de>,
278 {
279 let mut database_id__ = None;
280 let mut param__ = None;
281 while let Some(k) = map_.next_key()? {
282 match k {
283 GeneratedField::DatabaseId => {
284 if database_id__.is_some() {
285 return Err(serde::de::Error::duplicate_field("databaseId"));
286 }
287 database_id__ =
288 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
289 ;
290 }
291 GeneratedField::BarrierIntervalMs => {
292 if param__.is_some() {
293 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
294 }
295 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
296;
297 }
298 GeneratedField::CheckpointFrequency => {
299 if param__.is_some() {
300 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
301 }
302 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
303;
304 }
305 }
306 }
307 Ok(AlterDatabaseParamRequest {
308 database_id: database_id__.unwrap_or_default(),
309 param: param__,
310 })
311 }
312 }
313 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
314 }
315}
316impl serde::Serialize for AlterDatabaseParamResponse {
317 #[allow(deprecated)]
318 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
319 where
320 S: serde::Serializer,
321 {
322 use serde::ser::SerializeStruct;
323 let mut len = 0;
324 if self.status.is_some() {
325 len += 1;
326 }
327 if self.version.is_some() {
328 len += 1;
329 }
330 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
331 if let Some(v) = self.status.as_ref() {
332 struct_ser.serialize_field("status", v)?;
333 }
334 if let Some(v) = self.version.as_ref() {
335 struct_ser.serialize_field("version", v)?;
336 }
337 struct_ser.end()
338 }
339}
340impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
341 #[allow(deprecated)]
342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
343 where
344 D: serde::Deserializer<'de>,
345 {
346 const FIELDS: &[&str] = &[
347 "status",
348 "version",
349 ];
350
351 #[allow(clippy::enum_variant_names)]
352 enum GeneratedField {
353 Status,
354 Version,
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 match value {
376 "status" => Ok(GeneratedField::Status),
377 "version" => Ok(GeneratedField::Version),
378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
379 }
380 }
381 }
382 deserializer.deserialize_identifier(GeneratedVisitor)
383 }
384 }
385 struct GeneratedVisitor;
386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
387 type Value = AlterDatabaseParamResponse;
388
389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
390 formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
391 }
392
393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
394 where
395 V: serde::de::MapAccess<'de>,
396 {
397 let mut status__ = None;
398 let mut version__ = None;
399 while let Some(k) = map_.next_key()? {
400 match k {
401 GeneratedField::Status => {
402 if status__.is_some() {
403 return Err(serde::de::Error::duplicate_field("status"));
404 }
405 status__ = map_.next_value()?;
406 }
407 GeneratedField::Version => {
408 if version__.is_some() {
409 return Err(serde::de::Error::duplicate_field("version"));
410 }
411 version__ = map_.next_value()?;
412 }
413 }
414 }
415 Ok(AlterDatabaseParamResponse {
416 status: status__,
417 version: version__,
418 })
419 }
420 }
421 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
422 }
423}
424impl serde::Serialize for AlterFragmentParallelismRequest {
425 #[allow(deprecated)]
426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
427 where
428 S: serde::Serializer,
429 {
430 use serde::ser::SerializeStruct;
431 let mut len = 0;
432 if !self.fragment_ids.is_empty() {
433 len += 1;
434 }
435 if self.parallelism.is_some() {
436 len += 1;
437 }
438 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismRequest", len)?;
439 if !self.fragment_ids.is_empty() {
440 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
441 }
442 if let Some(v) = self.parallelism.as_ref() {
443 struct_ser.serialize_field("parallelism", v)?;
444 }
445 struct_ser.end()
446 }
447}
448impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismRequest {
449 #[allow(deprecated)]
450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
451 where
452 D: serde::Deserializer<'de>,
453 {
454 const FIELDS: &[&str] = &[
455 "fragment_ids",
456 "fragmentIds",
457 "parallelism",
458 ];
459
460 #[allow(clippy::enum_variant_names)]
461 enum GeneratedField {
462 FragmentIds,
463 Parallelism,
464 }
465 impl<'de> serde::Deserialize<'de> for GeneratedField {
466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
467 where
468 D: serde::Deserializer<'de>,
469 {
470 struct GeneratedVisitor;
471
472 impl serde::de::Visitor<'_> for GeneratedVisitor {
473 type Value = GeneratedField;
474
475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
476 write!(formatter, "expected one of: {:?}", &FIELDS)
477 }
478
479 #[allow(unused_variables)]
480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
481 where
482 E: serde::de::Error,
483 {
484 match value {
485 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
486 "parallelism" => Ok(GeneratedField::Parallelism),
487 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
488 }
489 }
490 }
491 deserializer.deserialize_identifier(GeneratedVisitor)
492 }
493 }
494 struct GeneratedVisitor;
495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
496 type Value = AlterFragmentParallelismRequest;
497
498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
499 formatter.write_str("struct ddl_service.AlterFragmentParallelismRequest")
500 }
501
502 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismRequest, V::Error>
503 where
504 V: serde::de::MapAccess<'de>,
505 {
506 let mut fragment_ids__ = None;
507 let mut parallelism__ = None;
508 while let Some(k) = map_.next_key()? {
509 match k {
510 GeneratedField::FragmentIds => {
511 if fragment_ids__.is_some() {
512 return Err(serde::de::Error::duplicate_field("fragmentIds"));
513 }
514 fragment_ids__ =
515 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
516 .into_iter().map(|x| x.0).collect())
517 ;
518 }
519 GeneratedField::Parallelism => {
520 if parallelism__.is_some() {
521 return Err(serde::de::Error::duplicate_field("parallelism"));
522 }
523 parallelism__ = map_.next_value()?;
524 }
525 }
526 }
527 Ok(AlterFragmentParallelismRequest {
528 fragment_ids: fragment_ids__.unwrap_or_default(),
529 parallelism: parallelism__,
530 })
531 }
532 }
533 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismRequest", FIELDS, GeneratedVisitor)
534 }
535}
536impl serde::Serialize for AlterFragmentParallelismResponse {
537 #[allow(deprecated)]
538 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
539 where
540 S: serde::Serializer,
541 {
542 use serde::ser::SerializeStruct;
543 let len = 0;
544 let struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismResponse", len)?;
545 struct_ser.end()
546 }
547}
548impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismResponse {
549 #[allow(deprecated)]
550 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
551 where
552 D: serde::Deserializer<'de>,
553 {
554 const FIELDS: &[&str] = &[
555 ];
556
557 #[allow(clippy::enum_variant_names)]
558 enum GeneratedField {
559 }
560 impl<'de> serde::Deserialize<'de> for GeneratedField {
561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
562 where
563 D: serde::Deserializer<'de>,
564 {
565 struct GeneratedVisitor;
566
567 impl serde::de::Visitor<'_> for GeneratedVisitor {
568 type Value = GeneratedField;
569
570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
571 write!(formatter, "expected one of: {:?}", &FIELDS)
572 }
573
574 #[allow(unused_variables)]
575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
576 where
577 E: serde::de::Error,
578 {
579 Err(serde::de::Error::unknown_field(value, FIELDS))
580 }
581 }
582 deserializer.deserialize_identifier(GeneratedVisitor)
583 }
584 }
585 struct GeneratedVisitor;
586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
587 type Value = AlterFragmentParallelismResponse;
588
589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
590 formatter.write_str("struct ddl_service.AlterFragmentParallelismResponse")
591 }
592
593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismResponse, V::Error>
594 where
595 V: serde::de::MapAccess<'de>,
596 {
597 while map_.next_key::<GeneratedField>()?.is_some() {
598 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
599 }
600 Ok(AlterFragmentParallelismResponse {
601 })
602 }
603 }
604 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismResponse", FIELDS, GeneratedVisitor)
605 }
606}
607impl serde::Serialize for AlterNameRequest {
608 #[allow(deprecated)]
609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
610 where
611 S: serde::Serializer,
612 {
613 use serde::ser::SerializeStruct;
614 let mut len = 0;
615 if !self.new_name.is_empty() {
616 len += 1;
617 }
618 if self.object.is_some() {
619 len += 1;
620 }
621 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
622 if !self.new_name.is_empty() {
623 struct_ser.serialize_field("newName", &self.new_name)?;
624 }
625 if let Some(v) = self.object.as_ref() {
626 match v {
627 alter_name_request::Object::TableId(v) => {
628 struct_ser.serialize_field("tableId", v)?;
629 }
630 alter_name_request::Object::ViewId(v) => {
631 struct_ser.serialize_field("viewId", v)?;
632 }
633 alter_name_request::Object::IndexId(v) => {
634 struct_ser.serialize_field("indexId", v)?;
635 }
636 alter_name_request::Object::SinkId(v) => {
637 struct_ser.serialize_field("sinkId", v)?;
638 }
639 alter_name_request::Object::SourceId(v) => {
640 struct_ser.serialize_field("sourceId", v)?;
641 }
642 alter_name_request::Object::SchemaId(v) => {
643 struct_ser.serialize_field("schemaId", v)?;
644 }
645 alter_name_request::Object::DatabaseId(v) => {
646 struct_ser.serialize_field("databaseId", v)?;
647 }
648 alter_name_request::Object::SubscriptionId(v) => {
649 struct_ser.serialize_field("subscriptionId", v)?;
650 }
651 }
652 }
653 struct_ser.end()
654 }
655}
656impl<'de> serde::Deserialize<'de> for AlterNameRequest {
657 #[allow(deprecated)]
658 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
659 where
660 D: serde::Deserializer<'de>,
661 {
662 const FIELDS: &[&str] = &[
663 "new_name",
664 "newName",
665 "table_id",
666 "tableId",
667 "view_id",
668 "viewId",
669 "index_id",
670 "indexId",
671 "sink_id",
672 "sinkId",
673 "source_id",
674 "sourceId",
675 "schema_id",
676 "schemaId",
677 "database_id",
678 "databaseId",
679 "subscription_id",
680 "subscriptionId",
681 ];
682
683 #[allow(clippy::enum_variant_names)]
684 enum GeneratedField {
685 NewName,
686 TableId,
687 ViewId,
688 IndexId,
689 SinkId,
690 SourceId,
691 SchemaId,
692 DatabaseId,
693 SubscriptionId,
694 }
695 impl<'de> serde::Deserialize<'de> for GeneratedField {
696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
697 where
698 D: serde::Deserializer<'de>,
699 {
700 struct GeneratedVisitor;
701
702 impl serde::de::Visitor<'_> for GeneratedVisitor {
703 type Value = GeneratedField;
704
705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
706 write!(formatter, "expected one of: {:?}", &FIELDS)
707 }
708
709 #[allow(unused_variables)]
710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
711 where
712 E: serde::de::Error,
713 {
714 match value {
715 "newName" | "new_name" => Ok(GeneratedField::NewName),
716 "tableId" | "table_id" => Ok(GeneratedField::TableId),
717 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
718 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
719 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
720 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
721 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
722 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
723 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
724 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
725 }
726 }
727 }
728 deserializer.deserialize_identifier(GeneratedVisitor)
729 }
730 }
731 struct GeneratedVisitor;
732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
733 type Value = AlterNameRequest;
734
735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
736 formatter.write_str("struct ddl_service.AlterNameRequest")
737 }
738
739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
740 where
741 V: serde::de::MapAccess<'de>,
742 {
743 let mut new_name__ = None;
744 let mut object__ = None;
745 while let Some(k) = map_.next_key()? {
746 match k {
747 GeneratedField::NewName => {
748 if new_name__.is_some() {
749 return Err(serde::de::Error::duplicate_field("newName"));
750 }
751 new_name__ = Some(map_.next_value()?);
752 }
753 GeneratedField::TableId => {
754 if object__.is_some() {
755 return Err(serde::de::Error::duplicate_field("tableId"));
756 }
757 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
758 }
759 GeneratedField::ViewId => {
760 if object__.is_some() {
761 return Err(serde::de::Error::duplicate_field("viewId"));
762 }
763 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
764 }
765 GeneratedField::IndexId => {
766 if object__.is_some() {
767 return Err(serde::de::Error::duplicate_field("indexId"));
768 }
769 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
770 }
771 GeneratedField::SinkId => {
772 if object__.is_some() {
773 return Err(serde::de::Error::duplicate_field("sinkId"));
774 }
775 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
776 }
777 GeneratedField::SourceId => {
778 if object__.is_some() {
779 return Err(serde::de::Error::duplicate_field("sourceId"));
780 }
781 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
782 }
783 GeneratedField::SchemaId => {
784 if object__.is_some() {
785 return Err(serde::de::Error::duplicate_field("schemaId"));
786 }
787 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
788 }
789 GeneratedField::DatabaseId => {
790 if object__.is_some() {
791 return Err(serde::de::Error::duplicate_field("databaseId"));
792 }
793 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
794 }
795 GeneratedField::SubscriptionId => {
796 if object__.is_some() {
797 return Err(serde::de::Error::duplicate_field("subscriptionId"));
798 }
799 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
800 }
801 }
802 }
803 Ok(AlterNameRequest {
804 new_name: new_name__.unwrap_or_default(),
805 object: object__,
806 })
807 }
808 }
809 deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
810 }
811}
812impl serde::Serialize for AlterNameResponse {
813 #[allow(deprecated)]
814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
815 where
816 S: serde::Serializer,
817 {
818 use serde::ser::SerializeStruct;
819 let mut len = 0;
820 if self.status.is_some() {
821 len += 1;
822 }
823 if self.version.is_some() {
824 len += 1;
825 }
826 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
827 if let Some(v) = self.status.as_ref() {
828 struct_ser.serialize_field("status", v)?;
829 }
830 if let Some(v) = self.version.as_ref() {
831 struct_ser.serialize_field("version", v)?;
832 }
833 struct_ser.end()
834 }
835}
836impl<'de> serde::Deserialize<'de> for AlterNameResponse {
837 #[allow(deprecated)]
838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
839 where
840 D: serde::Deserializer<'de>,
841 {
842 const FIELDS: &[&str] = &[
843 "status",
844 "version",
845 ];
846
847 #[allow(clippy::enum_variant_names)]
848 enum GeneratedField {
849 Status,
850 Version,
851 }
852 impl<'de> serde::Deserialize<'de> for GeneratedField {
853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
854 where
855 D: serde::Deserializer<'de>,
856 {
857 struct GeneratedVisitor;
858
859 impl serde::de::Visitor<'_> for GeneratedVisitor {
860 type Value = GeneratedField;
861
862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
863 write!(formatter, "expected one of: {:?}", &FIELDS)
864 }
865
866 #[allow(unused_variables)]
867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
868 where
869 E: serde::de::Error,
870 {
871 match value {
872 "status" => Ok(GeneratedField::Status),
873 "version" => Ok(GeneratedField::Version),
874 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
875 }
876 }
877 }
878 deserializer.deserialize_identifier(GeneratedVisitor)
879 }
880 }
881 struct GeneratedVisitor;
882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
883 type Value = AlterNameResponse;
884
885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
886 formatter.write_str("struct ddl_service.AlterNameResponse")
887 }
888
889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
890 where
891 V: serde::de::MapAccess<'de>,
892 {
893 let mut status__ = None;
894 let mut version__ = None;
895 while let Some(k) = map_.next_key()? {
896 match k {
897 GeneratedField::Status => {
898 if status__.is_some() {
899 return Err(serde::de::Error::duplicate_field("status"));
900 }
901 status__ = map_.next_value()?;
902 }
903 GeneratedField::Version => {
904 if version__.is_some() {
905 return Err(serde::de::Error::duplicate_field("version"));
906 }
907 version__ = map_.next_value()?;
908 }
909 }
910 }
911 Ok(AlterNameResponse {
912 status: status__,
913 version: version__,
914 })
915 }
916 }
917 deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
918 }
919}
920impl serde::Serialize for AlterOwnerRequest {
921 #[allow(deprecated)]
922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
923 where
924 S: serde::Serializer,
925 {
926 use serde::ser::SerializeStruct;
927 let mut len = 0;
928 if self.owner_id != 0 {
929 len += 1;
930 }
931 if self.object.is_some() {
932 len += 1;
933 }
934 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
935 if self.owner_id != 0 {
936 struct_ser.serialize_field("ownerId", &self.owner_id)?;
937 }
938 if let Some(v) = self.object.as_ref() {
939 match v {
940 alter_owner_request::Object::TableId(v) => {
941 struct_ser.serialize_field("tableId", v)?;
942 }
943 alter_owner_request::Object::ViewId(v) => {
944 struct_ser.serialize_field("viewId", v)?;
945 }
946 alter_owner_request::Object::SourceId(v) => {
947 struct_ser.serialize_field("sourceId", v)?;
948 }
949 alter_owner_request::Object::SinkId(v) => {
950 struct_ser.serialize_field("sinkId", v)?;
951 }
952 alter_owner_request::Object::SchemaId(v) => {
953 struct_ser.serialize_field("schemaId", v)?;
954 }
955 alter_owner_request::Object::DatabaseId(v) => {
956 struct_ser.serialize_field("databaseId", v)?;
957 }
958 alter_owner_request::Object::SubscriptionId(v) => {
959 struct_ser.serialize_field("subscriptionId", v)?;
960 }
961 alter_owner_request::Object::ConnectionId(v) => {
962 struct_ser.serialize_field("connectionId", v)?;
963 }
964 alter_owner_request::Object::SecretId(v) => {
965 struct_ser.serialize_field("secretId", v)?;
966 }
967 alter_owner_request::Object::FunctionId(v) => {
968 struct_ser.serialize_field("functionId", v)?;
969 }
970 }
971 }
972 struct_ser.end()
973 }
974}
975impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
976 #[allow(deprecated)]
977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
978 where
979 D: serde::Deserializer<'de>,
980 {
981 const FIELDS: &[&str] = &[
982 "owner_id",
983 "ownerId",
984 "table_id",
985 "tableId",
986 "view_id",
987 "viewId",
988 "source_id",
989 "sourceId",
990 "sink_id",
991 "sinkId",
992 "schema_id",
993 "schemaId",
994 "database_id",
995 "databaseId",
996 "subscription_id",
997 "subscriptionId",
998 "connection_id",
999 "connectionId",
1000 "secret_id",
1001 "secretId",
1002 "function_id",
1003 "functionId",
1004 ];
1005
1006 #[allow(clippy::enum_variant_names)]
1007 enum GeneratedField {
1008 OwnerId,
1009 TableId,
1010 ViewId,
1011 SourceId,
1012 SinkId,
1013 SchemaId,
1014 DatabaseId,
1015 SubscriptionId,
1016 ConnectionId,
1017 SecretId,
1018 FunctionId,
1019 }
1020 impl<'de> serde::Deserialize<'de> for GeneratedField {
1021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1022 where
1023 D: serde::Deserializer<'de>,
1024 {
1025 struct GeneratedVisitor;
1026
1027 impl serde::de::Visitor<'_> for GeneratedVisitor {
1028 type Value = GeneratedField;
1029
1030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1031 write!(formatter, "expected one of: {:?}", &FIELDS)
1032 }
1033
1034 #[allow(unused_variables)]
1035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1036 where
1037 E: serde::de::Error,
1038 {
1039 match value {
1040 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1041 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1042 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1043 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1044 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1045 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1046 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1047 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1048 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1049 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1050 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
1051 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1052 }
1053 }
1054 }
1055 deserializer.deserialize_identifier(GeneratedVisitor)
1056 }
1057 }
1058 struct GeneratedVisitor;
1059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1060 type Value = AlterOwnerRequest;
1061
1062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1063 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1064 }
1065
1066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1067 where
1068 V: serde::de::MapAccess<'de>,
1069 {
1070 let mut owner_id__ = None;
1071 let mut object__ = None;
1072 while let Some(k) = map_.next_key()? {
1073 match k {
1074 GeneratedField::OwnerId => {
1075 if owner_id__.is_some() {
1076 return Err(serde::de::Error::duplicate_field("ownerId"));
1077 }
1078 owner_id__ =
1079 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1080 ;
1081 }
1082 GeneratedField::TableId => {
1083 if object__.is_some() {
1084 return Err(serde::de::Error::duplicate_field("tableId"));
1085 }
1086 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1087 }
1088 GeneratedField::ViewId => {
1089 if object__.is_some() {
1090 return Err(serde::de::Error::duplicate_field("viewId"));
1091 }
1092 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1093 }
1094 GeneratedField::SourceId => {
1095 if object__.is_some() {
1096 return Err(serde::de::Error::duplicate_field("sourceId"));
1097 }
1098 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1099 }
1100 GeneratedField::SinkId => {
1101 if object__.is_some() {
1102 return Err(serde::de::Error::duplicate_field("sinkId"));
1103 }
1104 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1105 }
1106 GeneratedField::SchemaId => {
1107 if object__.is_some() {
1108 return Err(serde::de::Error::duplicate_field("schemaId"));
1109 }
1110 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1111 }
1112 GeneratedField::DatabaseId => {
1113 if object__.is_some() {
1114 return Err(serde::de::Error::duplicate_field("databaseId"));
1115 }
1116 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1117 }
1118 GeneratedField::SubscriptionId => {
1119 if object__.is_some() {
1120 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1121 }
1122 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1123 }
1124 GeneratedField::ConnectionId => {
1125 if object__.is_some() {
1126 return Err(serde::de::Error::duplicate_field("connectionId"));
1127 }
1128 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1129 }
1130 GeneratedField::SecretId => {
1131 if object__.is_some() {
1132 return Err(serde::de::Error::duplicate_field("secretId"));
1133 }
1134 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SecretId(x.0));
1135 }
1136 GeneratedField::FunctionId => {
1137 if object__.is_some() {
1138 return Err(serde::de::Error::duplicate_field("functionId"));
1139 }
1140 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::FunctionId(x.0));
1141 }
1142 }
1143 }
1144 Ok(AlterOwnerRequest {
1145 owner_id: owner_id__.unwrap_or_default(),
1146 object: object__,
1147 })
1148 }
1149 }
1150 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1151 }
1152}
1153impl serde::Serialize for AlterOwnerResponse {
1154 #[allow(deprecated)]
1155 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1156 where
1157 S: serde::Serializer,
1158 {
1159 use serde::ser::SerializeStruct;
1160 let mut len = 0;
1161 if self.status.is_some() {
1162 len += 1;
1163 }
1164 if self.version.is_some() {
1165 len += 1;
1166 }
1167 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1168 if let Some(v) = self.status.as_ref() {
1169 struct_ser.serialize_field("status", v)?;
1170 }
1171 if let Some(v) = self.version.as_ref() {
1172 struct_ser.serialize_field("version", v)?;
1173 }
1174 struct_ser.end()
1175 }
1176}
1177impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1178 #[allow(deprecated)]
1179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1180 where
1181 D: serde::Deserializer<'de>,
1182 {
1183 const FIELDS: &[&str] = &[
1184 "status",
1185 "version",
1186 ];
1187
1188 #[allow(clippy::enum_variant_names)]
1189 enum GeneratedField {
1190 Status,
1191 Version,
1192 }
1193 impl<'de> serde::Deserialize<'de> for GeneratedField {
1194 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1195 where
1196 D: serde::Deserializer<'de>,
1197 {
1198 struct GeneratedVisitor;
1199
1200 impl serde::de::Visitor<'_> for GeneratedVisitor {
1201 type Value = GeneratedField;
1202
1203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1204 write!(formatter, "expected one of: {:?}", &FIELDS)
1205 }
1206
1207 #[allow(unused_variables)]
1208 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1209 where
1210 E: serde::de::Error,
1211 {
1212 match value {
1213 "status" => Ok(GeneratedField::Status),
1214 "version" => Ok(GeneratedField::Version),
1215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1216 }
1217 }
1218 }
1219 deserializer.deserialize_identifier(GeneratedVisitor)
1220 }
1221 }
1222 struct GeneratedVisitor;
1223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1224 type Value = AlterOwnerResponse;
1225
1226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1227 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1228 }
1229
1230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1231 where
1232 V: serde::de::MapAccess<'de>,
1233 {
1234 let mut status__ = None;
1235 let mut version__ = None;
1236 while let Some(k) = map_.next_key()? {
1237 match k {
1238 GeneratedField::Status => {
1239 if status__.is_some() {
1240 return Err(serde::de::Error::duplicate_field("status"));
1241 }
1242 status__ = map_.next_value()?;
1243 }
1244 GeneratedField::Version => {
1245 if version__.is_some() {
1246 return Err(serde::de::Error::duplicate_field("version"));
1247 }
1248 version__ = map_.next_value()?;
1249 }
1250 }
1251 }
1252 Ok(AlterOwnerResponse {
1253 status: status__,
1254 version: version__,
1255 })
1256 }
1257 }
1258 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1259 }
1260}
1261impl serde::Serialize for AlterParallelismRequest {
1262 #[allow(deprecated)]
1263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1264 where
1265 S: serde::Serializer,
1266 {
1267 use serde::ser::SerializeStruct;
1268 let mut len = 0;
1269 if self.table_id != 0 {
1270 len += 1;
1271 }
1272 if self.parallelism.is_some() {
1273 len += 1;
1274 }
1275 if self.deferred {
1276 len += 1;
1277 }
1278 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1279 if self.table_id != 0 {
1280 struct_ser.serialize_field("tableId", &self.table_id)?;
1281 }
1282 if let Some(v) = self.parallelism.as_ref() {
1283 struct_ser.serialize_field("parallelism", v)?;
1284 }
1285 if self.deferred {
1286 struct_ser.serialize_field("deferred", &self.deferred)?;
1287 }
1288 struct_ser.end()
1289 }
1290}
1291impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
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 "table_id",
1299 "tableId",
1300 "parallelism",
1301 "deferred",
1302 ];
1303
1304 #[allow(clippy::enum_variant_names)]
1305 enum GeneratedField {
1306 TableId,
1307 Parallelism,
1308 Deferred,
1309 }
1310 impl<'de> serde::Deserialize<'de> for GeneratedField {
1311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1312 where
1313 D: serde::Deserializer<'de>,
1314 {
1315 struct GeneratedVisitor;
1316
1317 impl serde::de::Visitor<'_> for GeneratedVisitor {
1318 type Value = GeneratedField;
1319
1320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1321 write!(formatter, "expected one of: {:?}", &FIELDS)
1322 }
1323
1324 #[allow(unused_variables)]
1325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1326 where
1327 E: serde::de::Error,
1328 {
1329 match value {
1330 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1331 "parallelism" => Ok(GeneratedField::Parallelism),
1332 "deferred" => Ok(GeneratedField::Deferred),
1333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1334 }
1335 }
1336 }
1337 deserializer.deserialize_identifier(GeneratedVisitor)
1338 }
1339 }
1340 struct GeneratedVisitor;
1341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1342 type Value = AlterParallelismRequest;
1343
1344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1345 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1346 }
1347
1348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1349 where
1350 V: serde::de::MapAccess<'de>,
1351 {
1352 let mut table_id__ = None;
1353 let mut parallelism__ = None;
1354 let mut deferred__ = None;
1355 while let Some(k) = map_.next_key()? {
1356 match k {
1357 GeneratedField::TableId => {
1358 if table_id__.is_some() {
1359 return Err(serde::de::Error::duplicate_field("tableId"));
1360 }
1361 table_id__ =
1362 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1363 ;
1364 }
1365 GeneratedField::Parallelism => {
1366 if parallelism__.is_some() {
1367 return Err(serde::de::Error::duplicate_field("parallelism"));
1368 }
1369 parallelism__ = map_.next_value()?;
1370 }
1371 GeneratedField::Deferred => {
1372 if deferred__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("deferred"));
1374 }
1375 deferred__ = Some(map_.next_value()?);
1376 }
1377 }
1378 }
1379 Ok(AlterParallelismRequest {
1380 table_id: table_id__.unwrap_or_default(),
1381 parallelism: parallelism__,
1382 deferred: deferred__.unwrap_or_default(),
1383 })
1384 }
1385 }
1386 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1387 }
1388}
1389impl serde::Serialize for AlterParallelismResponse {
1390 #[allow(deprecated)]
1391 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1392 where
1393 S: serde::Serializer,
1394 {
1395 use serde::ser::SerializeStruct;
1396 let len = 0;
1397 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1398 struct_ser.end()
1399 }
1400}
1401impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1402 #[allow(deprecated)]
1403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1404 where
1405 D: serde::Deserializer<'de>,
1406 {
1407 const FIELDS: &[&str] = &[
1408 ];
1409
1410 #[allow(clippy::enum_variant_names)]
1411 enum GeneratedField {
1412 }
1413 impl<'de> serde::Deserialize<'de> for GeneratedField {
1414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1415 where
1416 D: serde::Deserializer<'de>,
1417 {
1418 struct GeneratedVisitor;
1419
1420 impl serde::de::Visitor<'_> for GeneratedVisitor {
1421 type Value = GeneratedField;
1422
1423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1424 write!(formatter, "expected one of: {:?}", &FIELDS)
1425 }
1426
1427 #[allow(unused_variables)]
1428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1429 where
1430 E: serde::de::Error,
1431 {
1432 Err(serde::de::Error::unknown_field(value, FIELDS))
1433 }
1434 }
1435 deserializer.deserialize_identifier(GeneratedVisitor)
1436 }
1437 }
1438 struct GeneratedVisitor;
1439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1440 type Value = AlterParallelismResponse;
1441
1442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1443 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1444 }
1445
1446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1447 where
1448 V: serde::de::MapAccess<'de>,
1449 {
1450 while map_.next_key::<GeneratedField>()?.is_some() {
1451 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1452 }
1453 Ok(AlterParallelismResponse {
1454 })
1455 }
1456 }
1457 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1458 }
1459}
1460impl serde::Serialize for AlterResourceGroupRequest {
1461 #[allow(deprecated)]
1462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1463 where
1464 S: serde::Serializer,
1465 {
1466 use serde::ser::SerializeStruct;
1467 let mut len = 0;
1468 if self.table_id != 0 {
1469 len += 1;
1470 }
1471 if self.resource_group.is_some() {
1472 len += 1;
1473 }
1474 if self.deferred {
1475 len += 1;
1476 }
1477 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1478 if self.table_id != 0 {
1479 struct_ser.serialize_field("tableId", &self.table_id)?;
1480 }
1481 if let Some(v) = self.resource_group.as_ref() {
1482 struct_ser.serialize_field("resourceGroup", v)?;
1483 }
1484 if self.deferred {
1485 struct_ser.serialize_field("deferred", &self.deferred)?;
1486 }
1487 struct_ser.end()
1488 }
1489}
1490impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1491 #[allow(deprecated)]
1492 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1493 where
1494 D: serde::Deserializer<'de>,
1495 {
1496 const FIELDS: &[&str] = &[
1497 "table_id",
1498 "tableId",
1499 "resource_group",
1500 "resourceGroup",
1501 "deferred",
1502 ];
1503
1504 #[allow(clippy::enum_variant_names)]
1505 enum GeneratedField {
1506 TableId,
1507 ResourceGroup,
1508 Deferred,
1509 }
1510 impl<'de> serde::Deserialize<'de> for GeneratedField {
1511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1512 where
1513 D: serde::Deserializer<'de>,
1514 {
1515 struct GeneratedVisitor;
1516
1517 impl serde::de::Visitor<'_> for GeneratedVisitor {
1518 type Value = GeneratedField;
1519
1520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1521 write!(formatter, "expected one of: {:?}", &FIELDS)
1522 }
1523
1524 #[allow(unused_variables)]
1525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1526 where
1527 E: serde::de::Error,
1528 {
1529 match value {
1530 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1531 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1532 "deferred" => Ok(GeneratedField::Deferred),
1533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1534 }
1535 }
1536 }
1537 deserializer.deserialize_identifier(GeneratedVisitor)
1538 }
1539 }
1540 struct GeneratedVisitor;
1541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1542 type Value = AlterResourceGroupRequest;
1543
1544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1545 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1546 }
1547
1548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1549 where
1550 V: serde::de::MapAccess<'de>,
1551 {
1552 let mut table_id__ = None;
1553 let mut resource_group__ = None;
1554 let mut deferred__ = None;
1555 while let Some(k) = map_.next_key()? {
1556 match k {
1557 GeneratedField::TableId => {
1558 if table_id__.is_some() {
1559 return Err(serde::de::Error::duplicate_field("tableId"));
1560 }
1561 table_id__ =
1562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1563 ;
1564 }
1565 GeneratedField::ResourceGroup => {
1566 if resource_group__.is_some() {
1567 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1568 }
1569 resource_group__ = map_.next_value()?;
1570 }
1571 GeneratedField::Deferred => {
1572 if deferred__.is_some() {
1573 return Err(serde::de::Error::duplicate_field("deferred"));
1574 }
1575 deferred__ = Some(map_.next_value()?);
1576 }
1577 }
1578 }
1579 Ok(AlterResourceGroupRequest {
1580 table_id: table_id__.unwrap_or_default(),
1581 resource_group: resource_group__,
1582 deferred: deferred__.unwrap_or_default(),
1583 })
1584 }
1585 }
1586 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1587 }
1588}
1589impl serde::Serialize for AlterResourceGroupResponse {
1590 #[allow(deprecated)]
1591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1592 where
1593 S: serde::Serializer,
1594 {
1595 use serde::ser::SerializeStruct;
1596 let len = 0;
1597 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1598 struct_ser.end()
1599 }
1600}
1601impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1602 #[allow(deprecated)]
1603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1604 where
1605 D: serde::Deserializer<'de>,
1606 {
1607 const FIELDS: &[&str] = &[
1608 ];
1609
1610 #[allow(clippy::enum_variant_names)]
1611 enum GeneratedField {
1612 }
1613 impl<'de> serde::Deserialize<'de> for GeneratedField {
1614 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1615 where
1616 D: serde::Deserializer<'de>,
1617 {
1618 struct GeneratedVisitor;
1619
1620 impl serde::de::Visitor<'_> for GeneratedVisitor {
1621 type Value = GeneratedField;
1622
1623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1624 write!(formatter, "expected one of: {:?}", &FIELDS)
1625 }
1626
1627 #[allow(unused_variables)]
1628 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1629 where
1630 E: serde::de::Error,
1631 {
1632 Err(serde::de::Error::unknown_field(value, FIELDS))
1633 }
1634 }
1635 deserializer.deserialize_identifier(GeneratedVisitor)
1636 }
1637 }
1638 struct GeneratedVisitor;
1639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1640 type Value = AlterResourceGroupResponse;
1641
1642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1643 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1644 }
1645
1646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1647 where
1648 V: serde::de::MapAccess<'de>,
1649 {
1650 while map_.next_key::<GeneratedField>()?.is_some() {
1651 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1652 }
1653 Ok(AlterResourceGroupResponse {
1654 })
1655 }
1656 }
1657 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1658 }
1659}
1660impl serde::Serialize for AlterSecretRequest {
1661 #[allow(deprecated)]
1662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1663 where
1664 S: serde::Serializer,
1665 {
1666 use serde::ser::SerializeStruct;
1667 let mut len = 0;
1668 if self.secret_id != 0 {
1669 len += 1;
1670 }
1671 if !self.name.is_empty() {
1672 len += 1;
1673 }
1674 if !self.value.is_empty() {
1675 len += 1;
1676 }
1677 if self.database_id != 0 {
1678 len += 1;
1679 }
1680 if self.schema_id != 0 {
1681 len += 1;
1682 }
1683 if self.owner_id != 0 {
1684 len += 1;
1685 }
1686 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1687 if self.secret_id != 0 {
1688 struct_ser.serialize_field("secretId", &self.secret_id)?;
1689 }
1690 if !self.name.is_empty() {
1691 struct_ser.serialize_field("name", &self.name)?;
1692 }
1693 if !self.value.is_empty() {
1694 #[allow(clippy::needless_borrow)]
1695 #[allow(clippy::needless_borrows_for_generic_args)]
1696 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1697 }
1698 if self.database_id != 0 {
1699 struct_ser.serialize_field("databaseId", &self.database_id)?;
1700 }
1701 if self.schema_id != 0 {
1702 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1703 }
1704 if self.owner_id != 0 {
1705 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1706 }
1707 struct_ser.end()
1708 }
1709}
1710impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1711 #[allow(deprecated)]
1712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1713 where
1714 D: serde::Deserializer<'de>,
1715 {
1716 const FIELDS: &[&str] = &[
1717 "secret_id",
1718 "secretId",
1719 "name",
1720 "value",
1721 "database_id",
1722 "databaseId",
1723 "schema_id",
1724 "schemaId",
1725 "owner_id",
1726 "ownerId",
1727 ];
1728
1729 #[allow(clippy::enum_variant_names)]
1730 enum GeneratedField {
1731 SecretId,
1732 Name,
1733 Value,
1734 DatabaseId,
1735 SchemaId,
1736 OwnerId,
1737 }
1738 impl<'de> serde::Deserialize<'de> for GeneratedField {
1739 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1740 where
1741 D: serde::Deserializer<'de>,
1742 {
1743 struct GeneratedVisitor;
1744
1745 impl serde::de::Visitor<'_> for GeneratedVisitor {
1746 type Value = GeneratedField;
1747
1748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1749 write!(formatter, "expected one of: {:?}", &FIELDS)
1750 }
1751
1752 #[allow(unused_variables)]
1753 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1754 where
1755 E: serde::de::Error,
1756 {
1757 match value {
1758 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1759 "name" => Ok(GeneratedField::Name),
1760 "value" => Ok(GeneratedField::Value),
1761 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1762 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1763 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1764 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1765 }
1766 }
1767 }
1768 deserializer.deserialize_identifier(GeneratedVisitor)
1769 }
1770 }
1771 struct GeneratedVisitor;
1772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1773 type Value = AlterSecretRequest;
1774
1775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1776 formatter.write_str("struct ddl_service.AlterSecretRequest")
1777 }
1778
1779 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
1780 where
1781 V: serde::de::MapAccess<'de>,
1782 {
1783 let mut secret_id__ = None;
1784 let mut name__ = None;
1785 let mut value__ = None;
1786 let mut database_id__ = None;
1787 let mut schema_id__ = None;
1788 let mut owner_id__ = None;
1789 while let Some(k) = map_.next_key()? {
1790 match k {
1791 GeneratedField::SecretId => {
1792 if secret_id__.is_some() {
1793 return Err(serde::de::Error::duplicate_field("secretId"));
1794 }
1795 secret_id__ =
1796 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1797 ;
1798 }
1799 GeneratedField::Name => {
1800 if name__.is_some() {
1801 return Err(serde::de::Error::duplicate_field("name"));
1802 }
1803 name__ = Some(map_.next_value()?);
1804 }
1805 GeneratedField::Value => {
1806 if value__.is_some() {
1807 return Err(serde::de::Error::duplicate_field("value"));
1808 }
1809 value__ =
1810 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
1811 ;
1812 }
1813 GeneratedField::DatabaseId => {
1814 if database_id__.is_some() {
1815 return Err(serde::de::Error::duplicate_field("databaseId"));
1816 }
1817 database_id__ =
1818 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1819 ;
1820 }
1821 GeneratedField::SchemaId => {
1822 if schema_id__.is_some() {
1823 return Err(serde::de::Error::duplicate_field("schemaId"));
1824 }
1825 schema_id__ =
1826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1827 ;
1828 }
1829 GeneratedField::OwnerId => {
1830 if owner_id__.is_some() {
1831 return Err(serde::de::Error::duplicate_field("ownerId"));
1832 }
1833 owner_id__ =
1834 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1835 ;
1836 }
1837 }
1838 }
1839 Ok(AlterSecretRequest {
1840 secret_id: secret_id__.unwrap_or_default(),
1841 name: name__.unwrap_or_default(),
1842 value: value__.unwrap_or_default(),
1843 database_id: database_id__.unwrap_or_default(),
1844 schema_id: schema_id__.unwrap_or_default(),
1845 owner_id: owner_id__.unwrap_or_default(),
1846 })
1847 }
1848 }
1849 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
1850 }
1851}
1852impl serde::Serialize for AlterSecretResponse {
1853 #[allow(deprecated)]
1854 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1855 where
1856 S: serde::Serializer,
1857 {
1858 use serde::ser::SerializeStruct;
1859 let mut len = 0;
1860 if self.version.is_some() {
1861 len += 1;
1862 }
1863 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
1864 if let Some(v) = self.version.as_ref() {
1865 struct_ser.serialize_field("version", v)?;
1866 }
1867 struct_ser.end()
1868 }
1869}
1870impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
1871 #[allow(deprecated)]
1872 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1873 where
1874 D: serde::Deserializer<'de>,
1875 {
1876 const FIELDS: &[&str] = &[
1877 "version",
1878 ];
1879
1880 #[allow(clippy::enum_variant_names)]
1881 enum GeneratedField {
1882 Version,
1883 }
1884 impl<'de> serde::Deserialize<'de> for GeneratedField {
1885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1886 where
1887 D: serde::Deserializer<'de>,
1888 {
1889 struct GeneratedVisitor;
1890
1891 impl serde::de::Visitor<'_> for GeneratedVisitor {
1892 type Value = GeneratedField;
1893
1894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1895 write!(formatter, "expected one of: {:?}", &FIELDS)
1896 }
1897
1898 #[allow(unused_variables)]
1899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1900 where
1901 E: serde::de::Error,
1902 {
1903 match value {
1904 "version" => Ok(GeneratedField::Version),
1905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1906 }
1907 }
1908 }
1909 deserializer.deserialize_identifier(GeneratedVisitor)
1910 }
1911 }
1912 struct GeneratedVisitor;
1913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1914 type Value = AlterSecretResponse;
1915
1916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1917 formatter.write_str("struct ddl_service.AlterSecretResponse")
1918 }
1919
1920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
1921 where
1922 V: serde::de::MapAccess<'de>,
1923 {
1924 let mut version__ = None;
1925 while let Some(k) = map_.next_key()? {
1926 match k {
1927 GeneratedField::Version => {
1928 if version__.is_some() {
1929 return Err(serde::de::Error::duplicate_field("version"));
1930 }
1931 version__ = map_.next_value()?;
1932 }
1933 }
1934 }
1935 Ok(AlterSecretResponse {
1936 version: version__,
1937 })
1938 }
1939 }
1940 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
1941 }
1942}
1943impl serde::Serialize for AlterSetSchemaRequest {
1944 #[allow(deprecated)]
1945 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1946 where
1947 S: serde::Serializer,
1948 {
1949 use serde::ser::SerializeStruct;
1950 let mut len = 0;
1951 if self.new_schema_id != 0 {
1952 len += 1;
1953 }
1954 if self.object.is_some() {
1955 len += 1;
1956 }
1957 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
1958 if self.new_schema_id != 0 {
1959 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
1960 }
1961 if let Some(v) = self.object.as_ref() {
1962 match v {
1963 alter_set_schema_request::Object::TableId(v) => {
1964 struct_ser.serialize_field("tableId", v)?;
1965 }
1966 alter_set_schema_request::Object::ViewId(v) => {
1967 struct_ser.serialize_field("viewId", v)?;
1968 }
1969 alter_set_schema_request::Object::SourceId(v) => {
1970 struct_ser.serialize_field("sourceId", v)?;
1971 }
1972 alter_set_schema_request::Object::SinkId(v) => {
1973 struct_ser.serialize_field("sinkId", v)?;
1974 }
1975 alter_set_schema_request::Object::FunctionId(v) => {
1976 struct_ser.serialize_field("functionId", v)?;
1977 }
1978 alter_set_schema_request::Object::ConnectionId(v) => {
1979 struct_ser.serialize_field("connectionId", v)?;
1980 }
1981 alter_set_schema_request::Object::SubscriptionId(v) => {
1982 struct_ser.serialize_field("subscriptionId", v)?;
1983 }
1984 }
1985 }
1986 struct_ser.end()
1987 }
1988}
1989impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
1990 #[allow(deprecated)]
1991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1992 where
1993 D: serde::Deserializer<'de>,
1994 {
1995 const FIELDS: &[&str] = &[
1996 "new_schema_id",
1997 "newSchemaId",
1998 "table_id",
1999 "tableId",
2000 "view_id",
2001 "viewId",
2002 "source_id",
2003 "sourceId",
2004 "sink_id",
2005 "sinkId",
2006 "function_id",
2007 "functionId",
2008 "connection_id",
2009 "connectionId",
2010 "subscription_id",
2011 "subscriptionId",
2012 ];
2013
2014 #[allow(clippy::enum_variant_names)]
2015 enum GeneratedField {
2016 NewSchemaId,
2017 TableId,
2018 ViewId,
2019 SourceId,
2020 SinkId,
2021 FunctionId,
2022 ConnectionId,
2023 SubscriptionId,
2024 }
2025 impl<'de> serde::Deserialize<'de> for GeneratedField {
2026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2027 where
2028 D: serde::Deserializer<'de>,
2029 {
2030 struct GeneratedVisitor;
2031
2032 impl serde::de::Visitor<'_> for GeneratedVisitor {
2033 type Value = GeneratedField;
2034
2035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2036 write!(formatter, "expected one of: {:?}", &FIELDS)
2037 }
2038
2039 #[allow(unused_variables)]
2040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2041 where
2042 E: serde::de::Error,
2043 {
2044 match value {
2045 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2046 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2047 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2048 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2049 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2050 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2051 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2052 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2054 }
2055 }
2056 }
2057 deserializer.deserialize_identifier(GeneratedVisitor)
2058 }
2059 }
2060 struct GeneratedVisitor;
2061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2062 type Value = AlterSetSchemaRequest;
2063
2064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2065 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2066 }
2067
2068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2069 where
2070 V: serde::de::MapAccess<'de>,
2071 {
2072 let mut new_schema_id__ = None;
2073 let mut object__ = None;
2074 while let Some(k) = map_.next_key()? {
2075 match k {
2076 GeneratedField::NewSchemaId => {
2077 if new_schema_id__.is_some() {
2078 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2079 }
2080 new_schema_id__ =
2081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2082 ;
2083 }
2084 GeneratedField::TableId => {
2085 if object__.is_some() {
2086 return Err(serde::de::Error::duplicate_field("tableId"));
2087 }
2088 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2089 }
2090 GeneratedField::ViewId => {
2091 if object__.is_some() {
2092 return Err(serde::de::Error::duplicate_field("viewId"));
2093 }
2094 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2095 }
2096 GeneratedField::SourceId => {
2097 if object__.is_some() {
2098 return Err(serde::de::Error::duplicate_field("sourceId"));
2099 }
2100 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2101 }
2102 GeneratedField::SinkId => {
2103 if object__.is_some() {
2104 return Err(serde::de::Error::duplicate_field("sinkId"));
2105 }
2106 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2107 }
2108 GeneratedField::FunctionId => {
2109 if object__.is_some() {
2110 return Err(serde::de::Error::duplicate_field("functionId"));
2111 }
2112 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2113 }
2114 GeneratedField::ConnectionId => {
2115 if object__.is_some() {
2116 return Err(serde::de::Error::duplicate_field("connectionId"));
2117 }
2118 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2119 }
2120 GeneratedField::SubscriptionId => {
2121 if object__.is_some() {
2122 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2123 }
2124 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2125 }
2126 }
2127 }
2128 Ok(AlterSetSchemaRequest {
2129 new_schema_id: new_schema_id__.unwrap_or_default(),
2130 object: object__,
2131 })
2132 }
2133 }
2134 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2135 }
2136}
2137impl serde::Serialize for AlterSetSchemaResponse {
2138 #[allow(deprecated)]
2139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2140 where
2141 S: serde::Serializer,
2142 {
2143 use serde::ser::SerializeStruct;
2144 let mut len = 0;
2145 if self.status.is_some() {
2146 len += 1;
2147 }
2148 if self.version.is_some() {
2149 len += 1;
2150 }
2151 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2152 if let Some(v) = self.status.as_ref() {
2153 struct_ser.serialize_field("status", v)?;
2154 }
2155 if let Some(v) = self.version.as_ref() {
2156 struct_ser.serialize_field("version", v)?;
2157 }
2158 struct_ser.end()
2159 }
2160}
2161impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2162 #[allow(deprecated)]
2163 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2164 where
2165 D: serde::Deserializer<'de>,
2166 {
2167 const FIELDS: &[&str] = &[
2168 "status",
2169 "version",
2170 ];
2171
2172 #[allow(clippy::enum_variant_names)]
2173 enum GeneratedField {
2174 Status,
2175 Version,
2176 }
2177 impl<'de> serde::Deserialize<'de> for GeneratedField {
2178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2179 where
2180 D: serde::Deserializer<'de>,
2181 {
2182 struct GeneratedVisitor;
2183
2184 impl serde::de::Visitor<'_> for GeneratedVisitor {
2185 type Value = GeneratedField;
2186
2187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2188 write!(formatter, "expected one of: {:?}", &FIELDS)
2189 }
2190
2191 #[allow(unused_variables)]
2192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2193 where
2194 E: serde::de::Error,
2195 {
2196 match value {
2197 "status" => Ok(GeneratedField::Status),
2198 "version" => Ok(GeneratedField::Version),
2199 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2200 }
2201 }
2202 }
2203 deserializer.deserialize_identifier(GeneratedVisitor)
2204 }
2205 }
2206 struct GeneratedVisitor;
2207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2208 type Value = AlterSetSchemaResponse;
2209
2210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2211 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2212 }
2213
2214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2215 where
2216 V: serde::de::MapAccess<'de>,
2217 {
2218 let mut status__ = None;
2219 let mut version__ = None;
2220 while let Some(k) = map_.next_key()? {
2221 match k {
2222 GeneratedField::Status => {
2223 if status__.is_some() {
2224 return Err(serde::de::Error::duplicate_field("status"));
2225 }
2226 status__ = map_.next_value()?;
2227 }
2228 GeneratedField::Version => {
2229 if version__.is_some() {
2230 return Err(serde::de::Error::duplicate_field("version"));
2231 }
2232 version__ = map_.next_value()?;
2233 }
2234 }
2235 }
2236 Ok(AlterSetSchemaResponse {
2237 status: status__,
2238 version: version__,
2239 })
2240 }
2241 }
2242 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2243 }
2244}
2245impl serde::Serialize for AlterSourceRequest {
2246 #[allow(deprecated)]
2247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2248 where
2249 S: serde::Serializer,
2250 {
2251 use serde::ser::SerializeStruct;
2252 let mut len = 0;
2253 if self.source.is_some() {
2254 len += 1;
2255 }
2256 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2257 if let Some(v) = self.source.as_ref() {
2258 struct_ser.serialize_field("source", v)?;
2259 }
2260 struct_ser.end()
2261 }
2262}
2263impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2264 #[allow(deprecated)]
2265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2266 where
2267 D: serde::Deserializer<'de>,
2268 {
2269 const FIELDS: &[&str] = &[
2270 "source",
2271 ];
2272
2273 #[allow(clippy::enum_variant_names)]
2274 enum GeneratedField {
2275 Source,
2276 }
2277 impl<'de> serde::Deserialize<'de> for GeneratedField {
2278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2279 where
2280 D: serde::Deserializer<'de>,
2281 {
2282 struct GeneratedVisitor;
2283
2284 impl serde::de::Visitor<'_> for GeneratedVisitor {
2285 type Value = GeneratedField;
2286
2287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2288 write!(formatter, "expected one of: {:?}", &FIELDS)
2289 }
2290
2291 #[allow(unused_variables)]
2292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2293 where
2294 E: serde::de::Error,
2295 {
2296 match value {
2297 "source" => Ok(GeneratedField::Source),
2298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2299 }
2300 }
2301 }
2302 deserializer.deserialize_identifier(GeneratedVisitor)
2303 }
2304 }
2305 struct GeneratedVisitor;
2306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2307 type Value = AlterSourceRequest;
2308
2309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2310 formatter.write_str("struct ddl_service.AlterSourceRequest")
2311 }
2312
2313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2314 where
2315 V: serde::de::MapAccess<'de>,
2316 {
2317 let mut source__ = None;
2318 while let Some(k) = map_.next_key()? {
2319 match k {
2320 GeneratedField::Source => {
2321 if source__.is_some() {
2322 return Err(serde::de::Error::duplicate_field("source"));
2323 }
2324 source__ = map_.next_value()?;
2325 }
2326 }
2327 }
2328 Ok(AlterSourceRequest {
2329 source: source__,
2330 })
2331 }
2332 }
2333 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2334 }
2335}
2336impl serde::Serialize for AlterSourceResponse {
2337 #[allow(deprecated)]
2338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2339 where
2340 S: serde::Serializer,
2341 {
2342 use serde::ser::SerializeStruct;
2343 let mut len = 0;
2344 if self.status.is_some() {
2345 len += 1;
2346 }
2347 if self.version.is_some() {
2348 len += 1;
2349 }
2350 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2351 if let Some(v) = self.status.as_ref() {
2352 struct_ser.serialize_field("status", v)?;
2353 }
2354 if let Some(v) = self.version.as_ref() {
2355 struct_ser.serialize_field("version", v)?;
2356 }
2357 struct_ser.end()
2358 }
2359}
2360impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2361 #[allow(deprecated)]
2362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2363 where
2364 D: serde::Deserializer<'de>,
2365 {
2366 const FIELDS: &[&str] = &[
2367 "status",
2368 "version",
2369 ];
2370
2371 #[allow(clippy::enum_variant_names)]
2372 enum GeneratedField {
2373 Status,
2374 Version,
2375 }
2376 impl<'de> serde::Deserialize<'de> for GeneratedField {
2377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2378 where
2379 D: serde::Deserializer<'de>,
2380 {
2381 struct GeneratedVisitor;
2382
2383 impl serde::de::Visitor<'_> for GeneratedVisitor {
2384 type Value = GeneratedField;
2385
2386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2387 write!(formatter, "expected one of: {:?}", &FIELDS)
2388 }
2389
2390 #[allow(unused_variables)]
2391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2392 where
2393 E: serde::de::Error,
2394 {
2395 match value {
2396 "status" => Ok(GeneratedField::Status),
2397 "version" => Ok(GeneratedField::Version),
2398 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2399 }
2400 }
2401 }
2402 deserializer.deserialize_identifier(GeneratedVisitor)
2403 }
2404 }
2405 struct GeneratedVisitor;
2406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2407 type Value = AlterSourceResponse;
2408
2409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2410 formatter.write_str("struct ddl_service.AlterSourceResponse")
2411 }
2412
2413 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2414 where
2415 V: serde::de::MapAccess<'de>,
2416 {
2417 let mut status__ = None;
2418 let mut version__ = None;
2419 while let Some(k) = map_.next_key()? {
2420 match k {
2421 GeneratedField::Status => {
2422 if status__.is_some() {
2423 return Err(serde::de::Error::duplicate_field("status"));
2424 }
2425 status__ = map_.next_value()?;
2426 }
2427 GeneratedField::Version => {
2428 if version__.is_some() {
2429 return Err(serde::de::Error::duplicate_field("version"));
2430 }
2431 version__ = map_.next_value()?;
2432 }
2433 }
2434 }
2435 Ok(AlterSourceResponse {
2436 status: status__,
2437 version: version__,
2438 })
2439 }
2440 }
2441 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2442 }
2443}
2444impl serde::Serialize for AlterStreamingJobConfigRequest {
2445 #[allow(deprecated)]
2446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2447 where
2448 S: serde::Serializer,
2449 {
2450 use serde::ser::SerializeStruct;
2451 let mut len = 0;
2452 if self.job_id != 0 {
2453 len += 1;
2454 }
2455 if !self.entries_to_add.is_empty() {
2456 len += 1;
2457 }
2458 if !self.keys_to_remove.is_empty() {
2459 len += 1;
2460 }
2461 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigRequest", len)?;
2462 if self.job_id != 0 {
2463 struct_ser.serialize_field("jobId", &self.job_id)?;
2464 }
2465 if !self.entries_to_add.is_empty() {
2466 struct_ser.serialize_field("entriesToAdd", &self.entries_to_add)?;
2467 }
2468 if !self.keys_to_remove.is_empty() {
2469 struct_ser.serialize_field("keysToRemove", &self.keys_to_remove)?;
2470 }
2471 struct_ser.end()
2472 }
2473}
2474impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigRequest {
2475 #[allow(deprecated)]
2476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2477 where
2478 D: serde::Deserializer<'de>,
2479 {
2480 const FIELDS: &[&str] = &[
2481 "job_id",
2482 "jobId",
2483 "entries_to_add",
2484 "entriesToAdd",
2485 "keys_to_remove",
2486 "keysToRemove",
2487 ];
2488
2489 #[allow(clippy::enum_variant_names)]
2490 enum GeneratedField {
2491 JobId,
2492 EntriesToAdd,
2493 KeysToRemove,
2494 }
2495 impl<'de> serde::Deserialize<'de> for GeneratedField {
2496 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2497 where
2498 D: serde::Deserializer<'de>,
2499 {
2500 struct GeneratedVisitor;
2501
2502 impl serde::de::Visitor<'_> for GeneratedVisitor {
2503 type Value = GeneratedField;
2504
2505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2506 write!(formatter, "expected one of: {:?}", &FIELDS)
2507 }
2508
2509 #[allow(unused_variables)]
2510 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2511 where
2512 E: serde::de::Error,
2513 {
2514 match value {
2515 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2516 "entriesToAdd" | "entries_to_add" => Ok(GeneratedField::EntriesToAdd),
2517 "keysToRemove" | "keys_to_remove" => Ok(GeneratedField::KeysToRemove),
2518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2519 }
2520 }
2521 }
2522 deserializer.deserialize_identifier(GeneratedVisitor)
2523 }
2524 }
2525 struct GeneratedVisitor;
2526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2527 type Value = AlterStreamingJobConfigRequest;
2528
2529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2530 formatter.write_str("struct ddl_service.AlterStreamingJobConfigRequest")
2531 }
2532
2533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigRequest, V::Error>
2534 where
2535 V: serde::de::MapAccess<'de>,
2536 {
2537 let mut job_id__ = None;
2538 let mut entries_to_add__ = None;
2539 let mut keys_to_remove__ = None;
2540 while let Some(k) = map_.next_key()? {
2541 match k {
2542 GeneratedField::JobId => {
2543 if job_id__.is_some() {
2544 return Err(serde::de::Error::duplicate_field("jobId"));
2545 }
2546 job_id__ =
2547 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2548 ;
2549 }
2550 GeneratedField::EntriesToAdd => {
2551 if entries_to_add__.is_some() {
2552 return Err(serde::de::Error::duplicate_field("entriesToAdd"));
2553 }
2554 entries_to_add__ = Some(
2555 map_.next_value::<std::collections::HashMap<_, _>>()?
2556 );
2557 }
2558 GeneratedField::KeysToRemove => {
2559 if keys_to_remove__.is_some() {
2560 return Err(serde::de::Error::duplicate_field("keysToRemove"));
2561 }
2562 keys_to_remove__ = Some(map_.next_value()?);
2563 }
2564 }
2565 }
2566 Ok(AlterStreamingJobConfigRequest {
2567 job_id: job_id__.unwrap_or_default(),
2568 entries_to_add: entries_to_add__.unwrap_or_default(),
2569 keys_to_remove: keys_to_remove__.unwrap_or_default(),
2570 })
2571 }
2572 }
2573 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigRequest", FIELDS, GeneratedVisitor)
2574 }
2575}
2576impl serde::Serialize for AlterStreamingJobConfigResponse {
2577 #[allow(deprecated)]
2578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2579 where
2580 S: serde::Serializer,
2581 {
2582 use serde::ser::SerializeStruct;
2583 let len = 0;
2584 let struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigResponse", len)?;
2585 struct_ser.end()
2586 }
2587}
2588impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigResponse {
2589 #[allow(deprecated)]
2590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2591 where
2592 D: serde::Deserializer<'de>,
2593 {
2594 const FIELDS: &[&str] = &[
2595 ];
2596
2597 #[allow(clippy::enum_variant_names)]
2598 enum GeneratedField {
2599 }
2600 impl<'de> serde::Deserialize<'de> for GeneratedField {
2601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2602 where
2603 D: serde::Deserializer<'de>,
2604 {
2605 struct GeneratedVisitor;
2606
2607 impl serde::de::Visitor<'_> for GeneratedVisitor {
2608 type Value = GeneratedField;
2609
2610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2611 write!(formatter, "expected one of: {:?}", &FIELDS)
2612 }
2613
2614 #[allow(unused_variables)]
2615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2616 where
2617 E: serde::de::Error,
2618 {
2619 Err(serde::de::Error::unknown_field(value, FIELDS))
2620 }
2621 }
2622 deserializer.deserialize_identifier(GeneratedVisitor)
2623 }
2624 }
2625 struct GeneratedVisitor;
2626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2627 type Value = AlterStreamingJobConfigResponse;
2628
2629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2630 formatter.write_str("struct ddl_service.AlterStreamingJobConfigResponse")
2631 }
2632
2633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigResponse, V::Error>
2634 where
2635 V: serde::de::MapAccess<'de>,
2636 {
2637 while map_.next_key::<GeneratedField>()?.is_some() {
2638 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2639 }
2640 Ok(AlterStreamingJobConfigResponse {
2641 })
2642 }
2643 }
2644 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigResponse", FIELDS, GeneratedVisitor)
2645 }
2646}
2647impl serde::Serialize for AlterSwapRenameRequest {
2648 #[allow(deprecated)]
2649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2650 where
2651 S: serde::Serializer,
2652 {
2653 use serde::ser::SerializeStruct;
2654 let mut len = 0;
2655 if self.object.is_some() {
2656 len += 1;
2657 }
2658 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
2659 if let Some(v) = self.object.as_ref() {
2660 match v {
2661 alter_swap_rename_request::Object::Schema(v) => {
2662 struct_ser.serialize_field("schema", v)?;
2663 }
2664 alter_swap_rename_request::Object::Table(v) => {
2665 struct_ser.serialize_field("table", v)?;
2666 }
2667 alter_swap_rename_request::Object::View(v) => {
2668 struct_ser.serialize_field("view", v)?;
2669 }
2670 alter_swap_rename_request::Object::Source(v) => {
2671 struct_ser.serialize_field("source", v)?;
2672 }
2673 alter_swap_rename_request::Object::Sink(v) => {
2674 struct_ser.serialize_field("sink", v)?;
2675 }
2676 alter_swap_rename_request::Object::Subscription(v) => {
2677 struct_ser.serialize_field("subscription", v)?;
2678 }
2679 }
2680 }
2681 struct_ser.end()
2682 }
2683}
2684impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
2685 #[allow(deprecated)]
2686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2687 where
2688 D: serde::Deserializer<'de>,
2689 {
2690 const FIELDS: &[&str] = &[
2691 "schema",
2692 "table",
2693 "view",
2694 "source",
2695 "sink",
2696 "subscription",
2697 ];
2698
2699 #[allow(clippy::enum_variant_names)]
2700 enum GeneratedField {
2701 Schema,
2702 Table,
2703 View,
2704 Source,
2705 Sink,
2706 Subscription,
2707 }
2708 impl<'de> serde::Deserialize<'de> for GeneratedField {
2709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2710 where
2711 D: serde::Deserializer<'de>,
2712 {
2713 struct GeneratedVisitor;
2714
2715 impl serde::de::Visitor<'_> for GeneratedVisitor {
2716 type Value = GeneratedField;
2717
2718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2719 write!(formatter, "expected one of: {:?}", &FIELDS)
2720 }
2721
2722 #[allow(unused_variables)]
2723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2724 where
2725 E: serde::de::Error,
2726 {
2727 match value {
2728 "schema" => Ok(GeneratedField::Schema),
2729 "table" => Ok(GeneratedField::Table),
2730 "view" => Ok(GeneratedField::View),
2731 "source" => Ok(GeneratedField::Source),
2732 "sink" => Ok(GeneratedField::Sink),
2733 "subscription" => Ok(GeneratedField::Subscription),
2734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2735 }
2736 }
2737 }
2738 deserializer.deserialize_identifier(GeneratedVisitor)
2739 }
2740 }
2741 struct GeneratedVisitor;
2742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2743 type Value = AlterSwapRenameRequest;
2744
2745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2746 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
2747 }
2748
2749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
2750 where
2751 V: serde::de::MapAccess<'de>,
2752 {
2753 let mut object__ = None;
2754 while let Some(k) = map_.next_key()? {
2755 match k {
2756 GeneratedField::Schema => {
2757 if object__.is_some() {
2758 return Err(serde::de::Error::duplicate_field("schema"));
2759 }
2760 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
2761;
2762 }
2763 GeneratedField::Table => {
2764 if object__.is_some() {
2765 return Err(serde::de::Error::duplicate_field("table"));
2766 }
2767 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
2768;
2769 }
2770 GeneratedField::View => {
2771 if object__.is_some() {
2772 return Err(serde::de::Error::duplicate_field("view"));
2773 }
2774 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
2775;
2776 }
2777 GeneratedField::Source => {
2778 if object__.is_some() {
2779 return Err(serde::de::Error::duplicate_field("source"));
2780 }
2781 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
2782;
2783 }
2784 GeneratedField::Sink => {
2785 if object__.is_some() {
2786 return Err(serde::de::Error::duplicate_field("sink"));
2787 }
2788 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
2789;
2790 }
2791 GeneratedField::Subscription => {
2792 if object__.is_some() {
2793 return Err(serde::de::Error::duplicate_field("subscription"));
2794 }
2795 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
2796;
2797 }
2798 }
2799 }
2800 Ok(AlterSwapRenameRequest {
2801 object: object__,
2802 })
2803 }
2804 }
2805 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
2806 }
2807}
2808impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
2809 #[allow(deprecated)]
2810 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2811 where
2812 S: serde::Serializer,
2813 {
2814 use serde::ser::SerializeStruct;
2815 let mut len = 0;
2816 if self.src_object_id != 0 {
2817 len += 1;
2818 }
2819 if self.dst_object_id != 0 {
2820 len += 1;
2821 }
2822 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
2823 if self.src_object_id != 0 {
2824 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
2825 }
2826 if self.dst_object_id != 0 {
2827 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
2828 }
2829 struct_ser.end()
2830 }
2831}
2832impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
2833 #[allow(deprecated)]
2834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2835 where
2836 D: serde::Deserializer<'de>,
2837 {
2838 const FIELDS: &[&str] = &[
2839 "src_object_id",
2840 "srcObjectId",
2841 "dst_object_id",
2842 "dstObjectId",
2843 ];
2844
2845 #[allow(clippy::enum_variant_names)]
2846 enum GeneratedField {
2847 SrcObjectId,
2848 DstObjectId,
2849 }
2850 impl<'de> serde::Deserialize<'de> for GeneratedField {
2851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2852 where
2853 D: serde::Deserializer<'de>,
2854 {
2855 struct GeneratedVisitor;
2856
2857 impl serde::de::Visitor<'_> for GeneratedVisitor {
2858 type Value = GeneratedField;
2859
2860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2861 write!(formatter, "expected one of: {:?}", &FIELDS)
2862 }
2863
2864 #[allow(unused_variables)]
2865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2866 where
2867 E: serde::de::Error,
2868 {
2869 match value {
2870 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
2871 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
2872 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2873 }
2874 }
2875 }
2876 deserializer.deserialize_identifier(GeneratedVisitor)
2877 }
2878 }
2879 struct GeneratedVisitor;
2880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2881 type Value = alter_swap_rename_request::ObjectNameSwapPair;
2882
2883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2884 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
2885 }
2886
2887 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
2888 where
2889 V: serde::de::MapAccess<'de>,
2890 {
2891 let mut src_object_id__ = None;
2892 let mut dst_object_id__ = None;
2893 while let Some(k) = map_.next_key()? {
2894 match k {
2895 GeneratedField::SrcObjectId => {
2896 if src_object_id__.is_some() {
2897 return Err(serde::de::Error::duplicate_field("srcObjectId"));
2898 }
2899 src_object_id__ =
2900 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2901 ;
2902 }
2903 GeneratedField::DstObjectId => {
2904 if dst_object_id__.is_some() {
2905 return Err(serde::de::Error::duplicate_field("dstObjectId"));
2906 }
2907 dst_object_id__ =
2908 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2909 ;
2910 }
2911 }
2912 }
2913 Ok(alter_swap_rename_request::ObjectNameSwapPair {
2914 src_object_id: src_object_id__.unwrap_or_default(),
2915 dst_object_id: dst_object_id__.unwrap_or_default(),
2916 })
2917 }
2918 }
2919 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
2920 }
2921}
2922impl serde::Serialize for AlterSwapRenameResponse {
2923 #[allow(deprecated)]
2924 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2925 where
2926 S: serde::Serializer,
2927 {
2928 use serde::ser::SerializeStruct;
2929 let mut len = 0;
2930 if self.status.is_some() {
2931 len += 1;
2932 }
2933 if self.version.is_some() {
2934 len += 1;
2935 }
2936 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
2937 if let Some(v) = self.status.as_ref() {
2938 struct_ser.serialize_field("status", v)?;
2939 }
2940 if let Some(v) = self.version.as_ref() {
2941 struct_ser.serialize_field("version", v)?;
2942 }
2943 struct_ser.end()
2944 }
2945}
2946impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
2947 #[allow(deprecated)]
2948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2949 where
2950 D: serde::Deserializer<'de>,
2951 {
2952 const FIELDS: &[&str] = &[
2953 "status",
2954 "version",
2955 ];
2956
2957 #[allow(clippy::enum_variant_names)]
2958 enum GeneratedField {
2959 Status,
2960 Version,
2961 }
2962 impl<'de> serde::Deserialize<'de> for GeneratedField {
2963 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2964 where
2965 D: serde::Deserializer<'de>,
2966 {
2967 struct GeneratedVisitor;
2968
2969 impl serde::de::Visitor<'_> for GeneratedVisitor {
2970 type Value = GeneratedField;
2971
2972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2973 write!(formatter, "expected one of: {:?}", &FIELDS)
2974 }
2975
2976 #[allow(unused_variables)]
2977 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2978 where
2979 E: serde::de::Error,
2980 {
2981 match value {
2982 "status" => Ok(GeneratedField::Status),
2983 "version" => Ok(GeneratedField::Version),
2984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2985 }
2986 }
2987 }
2988 deserializer.deserialize_identifier(GeneratedVisitor)
2989 }
2990 }
2991 struct GeneratedVisitor;
2992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2993 type Value = AlterSwapRenameResponse;
2994
2995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2996 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
2997 }
2998
2999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
3000 where
3001 V: serde::de::MapAccess<'de>,
3002 {
3003 let mut status__ = None;
3004 let mut version__ = None;
3005 while let Some(k) = map_.next_key()? {
3006 match k {
3007 GeneratedField::Status => {
3008 if status__.is_some() {
3009 return Err(serde::de::Error::duplicate_field("status"));
3010 }
3011 status__ = map_.next_value()?;
3012 }
3013 GeneratedField::Version => {
3014 if version__.is_some() {
3015 return Err(serde::de::Error::duplicate_field("version"));
3016 }
3017 version__ = map_.next_value()?;
3018 }
3019 }
3020 }
3021 Ok(AlterSwapRenameResponse {
3022 status: status__,
3023 version: version__,
3024 })
3025 }
3026 }
3027 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
3028 }
3029}
3030impl serde::Serialize for AutoSchemaChangeRequest {
3031 #[allow(deprecated)]
3032 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3033 where
3034 S: serde::Serializer,
3035 {
3036 use serde::ser::SerializeStruct;
3037 let mut len = 0;
3038 if self.schema_change.is_some() {
3039 len += 1;
3040 }
3041 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
3042 if let Some(v) = self.schema_change.as_ref() {
3043 struct_ser.serialize_field("schemaChange", v)?;
3044 }
3045 struct_ser.end()
3046 }
3047}
3048impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
3049 #[allow(deprecated)]
3050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3051 where
3052 D: serde::Deserializer<'de>,
3053 {
3054 const FIELDS: &[&str] = &[
3055 "schema_change",
3056 "schemaChange",
3057 ];
3058
3059 #[allow(clippy::enum_variant_names)]
3060 enum GeneratedField {
3061 SchemaChange,
3062 }
3063 impl<'de> serde::Deserialize<'de> for GeneratedField {
3064 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3065 where
3066 D: serde::Deserializer<'de>,
3067 {
3068 struct GeneratedVisitor;
3069
3070 impl serde::de::Visitor<'_> for GeneratedVisitor {
3071 type Value = GeneratedField;
3072
3073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3074 write!(formatter, "expected one of: {:?}", &FIELDS)
3075 }
3076
3077 #[allow(unused_variables)]
3078 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3079 where
3080 E: serde::de::Error,
3081 {
3082 match value {
3083 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
3084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3085 }
3086 }
3087 }
3088 deserializer.deserialize_identifier(GeneratedVisitor)
3089 }
3090 }
3091 struct GeneratedVisitor;
3092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3093 type Value = AutoSchemaChangeRequest;
3094
3095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3096 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
3097 }
3098
3099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
3100 where
3101 V: serde::de::MapAccess<'de>,
3102 {
3103 let mut schema_change__ = None;
3104 while let Some(k) = map_.next_key()? {
3105 match k {
3106 GeneratedField::SchemaChange => {
3107 if schema_change__.is_some() {
3108 return Err(serde::de::Error::duplicate_field("schemaChange"));
3109 }
3110 schema_change__ = map_.next_value()?;
3111 }
3112 }
3113 }
3114 Ok(AutoSchemaChangeRequest {
3115 schema_change: schema_change__,
3116 })
3117 }
3118 }
3119 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
3120 }
3121}
3122impl serde::Serialize for AutoSchemaChangeResponse {
3123 #[allow(deprecated)]
3124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3125 where
3126 S: serde::Serializer,
3127 {
3128 use serde::ser::SerializeStruct;
3129 let len = 0;
3130 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
3131 struct_ser.end()
3132 }
3133}
3134impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
3135 #[allow(deprecated)]
3136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3137 where
3138 D: serde::Deserializer<'de>,
3139 {
3140 const FIELDS: &[&str] = &[
3141 ];
3142
3143 #[allow(clippy::enum_variant_names)]
3144 enum GeneratedField {
3145 }
3146 impl<'de> serde::Deserialize<'de> for GeneratedField {
3147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3148 where
3149 D: serde::Deserializer<'de>,
3150 {
3151 struct GeneratedVisitor;
3152
3153 impl serde::de::Visitor<'_> for GeneratedVisitor {
3154 type Value = GeneratedField;
3155
3156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3157 write!(formatter, "expected one of: {:?}", &FIELDS)
3158 }
3159
3160 #[allow(unused_variables)]
3161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3162 where
3163 E: serde::de::Error,
3164 {
3165 Err(serde::de::Error::unknown_field(value, FIELDS))
3166 }
3167 }
3168 deserializer.deserialize_identifier(GeneratedVisitor)
3169 }
3170 }
3171 struct GeneratedVisitor;
3172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3173 type Value = AutoSchemaChangeResponse;
3174
3175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3176 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
3177 }
3178
3179 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
3180 where
3181 V: serde::de::MapAccess<'de>,
3182 {
3183 while map_.next_key::<GeneratedField>()?.is_some() {
3184 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3185 }
3186 Ok(AutoSchemaChangeResponse {
3187 })
3188 }
3189 }
3190 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
3191 }
3192}
3193impl serde::Serialize for BackfillType {
3194 #[allow(deprecated)]
3195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3196 where
3197 S: serde::Serializer,
3198 {
3199 let variant = match self {
3200 Self::Unspecified => "BACKFILL_TYPE_UNSPECIFIED",
3201 Self::NormalBackfill => "NORMAL_BACKFILL",
3202 Self::SnapshotBackfill => "SNAPSHOT_BACKFILL",
3203 };
3204 serializer.serialize_str(variant)
3205 }
3206}
3207impl<'de> serde::Deserialize<'de> for BackfillType {
3208 #[allow(deprecated)]
3209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3210 where
3211 D: serde::Deserializer<'de>,
3212 {
3213 const FIELDS: &[&str] = &[
3214 "BACKFILL_TYPE_UNSPECIFIED",
3215 "NORMAL_BACKFILL",
3216 "SNAPSHOT_BACKFILL",
3217 ];
3218
3219 struct GeneratedVisitor;
3220
3221 impl serde::de::Visitor<'_> for GeneratedVisitor {
3222 type Value = BackfillType;
3223
3224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3225 write!(formatter, "expected one of: {:?}", &FIELDS)
3226 }
3227
3228 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3229 where
3230 E: serde::de::Error,
3231 {
3232 i32::try_from(v)
3233 .ok()
3234 .and_then(|x| x.try_into().ok())
3235 .ok_or_else(|| {
3236 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3237 })
3238 }
3239
3240 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3241 where
3242 E: serde::de::Error,
3243 {
3244 i32::try_from(v)
3245 .ok()
3246 .and_then(|x| x.try_into().ok())
3247 .ok_or_else(|| {
3248 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3249 })
3250 }
3251
3252 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3253 where
3254 E: serde::de::Error,
3255 {
3256 match value {
3257 "BACKFILL_TYPE_UNSPECIFIED" => Ok(BackfillType::Unspecified),
3258 "NORMAL_BACKFILL" => Ok(BackfillType::NormalBackfill),
3259 "SNAPSHOT_BACKFILL" => Ok(BackfillType::SnapshotBackfill),
3260 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3261 }
3262 }
3263 }
3264 deserializer.deserialize_any(GeneratedVisitor)
3265 }
3266}
3267impl serde::Serialize for CommentOnRequest {
3268 #[allow(deprecated)]
3269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3270 where
3271 S: serde::Serializer,
3272 {
3273 use serde::ser::SerializeStruct;
3274 let mut len = 0;
3275 if self.comment.is_some() {
3276 len += 1;
3277 }
3278 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
3279 if let Some(v) = self.comment.as_ref() {
3280 struct_ser.serialize_field("comment", v)?;
3281 }
3282 struct_ser.end()
3283 }
3284}
3285impl<'de> serde::Deserialize<'de> for CommentOnRequest {
3286 #[allow(deprecated)]
3287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3288 where
3289 D: serde::Deserializer<'de>,
3290 {
3291 const FIELDS: &[&str] = &[
3292 "comment",
3293 ];
3294
3295 #[allow(clippy::enum_variant_names)]
3296 enum GeneratedField {
3297 Comment,
3298 }
3299 impl<'de> serde::Deserialize<'de> for GeneratedField {
3300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3301 where
3302 D: serde::Deserializer<'de>,
3303 {
3304 struct GeneratedVisitor;
3305
3306 impl serde::de::Visitor<'_> for GeneratedVisitor {
3307 type Value = GeneratedField;
3308
3309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3310 write!(formatter, "expected one of: {:?}", &FIELDS)
3311 }
3312
3313 #[allow(unused_variables)]
3314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3315 where
3316 E: serde::de::Error,
3317 {
3318 match value {
3319 "comment" => Ok(GeneratedField::Comment),
3320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3321 }
3322 }
3323 }
3324 deserializer.deserialize_identifier(GeneratedVisitor)
3325 }
3326 }
3327 struct GeneratedVisitor;
3328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3329 type Value = CommentOnRequest;
3330
3331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3332 formatter.write_str("struct ddl_service.CommentOnRequest")
3333 }
3334
3335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
3336 where
3337 V: serde::de::MapAccess<'de>,
3338 {
3339 let mut comment__ = None;
3340 while let Some(k) = map_.next_key()? {
3341 match k {
3342 GeneratedField::Comment => {
3343 if comment__.is_some() {
3344 return Err(serde::de::Error::duplicate_field("comment"));
3345 }
3346 comment__ = map_.next_value()?;
3347 }
3348 }
3349 }
3350 Ok(CommentOnRequest {
3351 comment: comment__,
3352 })
3353 }
3354 }
3355 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
3356 }
3357}
3358impl serde::Serialize for CommentOnResponse {
3359 #[allow(deprecated)]
3360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3361 where
3362 S: serde::Serializer,
3363 {
3364 use serde::ser::SerializeStruct;
3365 let mut len = 0;
3366 if self.status.is_some() {
3367 len += 1;
3368 }
3369 if self.version.is_some() {
3370 len += 1;
3371 }
3372 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
3373 if let Some(v) = self.status.as_ref() {
3374 struct_ser.serialize_field("status", v)?;
3375 }
3376 if let Some(v) = self.version.as_ref() {
3377 struct_ser.serialize_field("version", v)?;
3378 }
3379 struct_ser.end()
3380 }
3381}
3382impl<'de> serde::Deserialize<'de> for CommentOnResponse {
3383 #[allow(deprecated)]
3384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3385 where
3386 D: serde::Deserializer<'de>,
3387 {
3388 const FIELDS: &[&str] = &[
3389 "status",
3390 "version",
3391 ];
3392
3393 #[allow(clippy::enum_variant_names)]
3394 enum GeneratedField {
3395 Status,
3396 Version,
3397 }
3398 impl<'de> serde::Deserialize<'de> for GeneratedField {
3399 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3400 where
3401 D: serde::Deserializer<'de>,
3402 {
3403 struct GeneratedVisitor;
3404
3405 impl serde::de::Visitor<'_> for GeneratedVisitor {
3406 type Value = GeneratedField;
3407
3408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3409 write!(formatter, "expected one of: {:?}", &FIELDS)
3410 }
3411
3412 #[allow(unused_variables)]
3413 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3414 where
3415 E: serde::de::Error,
3416 {
3417 match value {
3418 "status" => Ok(GeneratedField::Status),
3419 "version" => Ok(GeneratedField::Version),
3420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3421 }
3422 }
3423 }
3424 deserializer.deserialize_identifier(GeneratedVisitor)
3425 }
3426 }
3427 struct GeneratedVisitor;
3428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3429 type Value = CommentOnResponse;
3430
3431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3432 formatter.write_str("struct ddl_service.CommentOnResponse")
3433 }
3434
3435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
3436 where
3437 V: serde::de::MapAccess<'de>,
3438 {
3439 let mut status__ = None;
3440 let mut version__ = None;
3441 while let Some(k) = map_.next_key()? {
3442 match k {
3443 GeneratedField::Status => {
3444 if status__.is_some() {
3445 return Err(serde::de::Error::duplicate_field("status"));
3446 }
3447 status__ = map_.next_value()?;
3448 }
3449 GeneratedField::Version => {
3450 if version__.is_some() {
3451 return Err(serde::de::Error::duplicate_field("version"));
3452 }
3453 version__ = map_.next_value()?;
3454 }
3455 }
3456 }
3457 Ok(CommentOnResponse {
3458 status: status__,
3459 version: version__,
3460 })
3461 }
3462 }
3463 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
3464 }
3465}
3466impl serde::Serialize for CompactIcebergTableRequest {
3467 #[allow(deprecated)]
3468 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3469 where
3470 S: serde::Serializer,
3471 {
3472 use serde::ser::SerializeStruct;
3473 let mut len = 0;
3474 if self.sink_id != 0 {
3475 len += 1;
3476 }
3477 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
3478 if self.sink_id != 0 {
3479 struct_ser.serialize_field("sinkId", &self.sink_id)?;
3480 }
3481 struct_ser.end()
3482 }
3483}
3484impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
3485 #[allow(deprecated)]
3486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3487 where
3488 D: serde::Deserializer<'de>,
3489 {
3490 const FIELDS: &[&str] = &[
3491 "sink_id",
3492 "sinkId",
3493 ];
3494
3495 #[allow(clippy::enum_variant_names)]
3496 enum GeneratedField {
3497 SinkId,
3498 }
3499 impl<'de> serde::Deserialize<'de> for GeneratedField {
3500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3501 where
3502 D: serde::Deserializer<'de>,
3503 {
3504 struct GeneratedVisitor;
3505
3506 impl serde::de::Visitor<'_> for GeneratedVisitor {
3507 type Value = GeneratedField;
3508
3509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3510 write!(formatter, "expected one of: {:?}", &FIELDS)
3511 }
3512
3513 #[allow(unused_variables)]
3514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3515 where
3516 E: serde::de::Error,
3517 {
3518 match value {
3519 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
3520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3521 }
3522 }
3523 }
3524 deserializer.deserialize_identifier(GeneratedVisitor)
3525 }
3526 }
3527 struct GeneratedVisitor;
3528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3529 type Value = CompactIcebergTableRequest;
3530
3531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3532 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
3533 }
3534
3535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
3536 where
3537 V: serde::de::MapAccess<'de>,
3538 {
3539 let mut sink_id__ = None;
3540 while let Some(k) = map_.next_key()? {
3541 match k {
3542 GeneratedField::SinkId => {
3543 if sink_id__.is_some() {
3544 return Err(serde::de::Error::duplicate_field("sinkId"));
3545 }
3546 sink_id__ =
3547 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3548 ;
3549 }
3550 }
3551 }
3552 Ok(CompactIcebergTableRequest {
3553 sink_id: sink_id__.unwrap_or_default(),
3554 })
3555 }
3556 }
3557 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
3558 }
3559}
3560impl serde::Serialize for CompactIcebergTableResponse {
3561 #[allow(deprecated)]
3562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3563 where
3564 S: serde::Serializer,
3565 {
3566 use serde::ser::SerializeStruct;
3567 let mut len = 0;
3568 if self.status.is_some() {
3569 len += 1;
3570 }
3571 if self.task_id != 0 {
3572 len += 1;
3573 }
3574 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
3575 if let Some(v) = self.status.as_ref() {
3576 struct_ser.serialize_field("status", v)?;
3577 }
3578 if self.task_id != 0 {
3579 #[allow(clippy::needless_borrow)]
3580 #[allow(clippy::needless_borrows_for_generic_args)]
3581 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
3582 }
3583 struct_ser.end()
3584 }
3585}
3586impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
3587 #[allow(deprecated)]
3588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3589 where
3590 D: serde::Deserializer<'de>,
3591 {
3592 const FIELDS: &[&str] = &[
3593 "status",
3594 "task_id",
3595 "taskId",
3596 ];
3597
3598 #[allow(clippy::enum_variant_names)]
3599 enum GeneratedField {
3600 Status,
3601 TaskId,
3602 }
3603 impl<'de> serde::Deserialize<'de> for GeneratedField {
3604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3605 where
3606 D: serde::Deserializer<'de>,
3607 {
3608 struct GeneratedVisitor;
3609
3610 impl serde::de::Visitor<'_> for GeneratedVisitor {
3611 type Value = GeneratedField;
3612
3613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3614 write!(formatter, "expected one of: {:?}", &FIELDS)
3615 }
3616
3617 #[allow(unused_variables)]
3618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3619 where
3620 E: serde::de::Error,
3621 {
3622 match value {
3623 "status" => Ok(GeneratedField::Status),
3624 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
3625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3626 }
3627 }
3628 }
3629 deserializer.deserialize_identifier(GeneratedVisitor)
3630 }
3631 }
3632 struct GeneratedVisitor;
3633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3634 type Value = CompactIcebergTableResponse;
3635
3636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3637 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
3638 }
3639
3640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
3641 where
3642 V: serde::de::MapAccess<'de>,
3643 {
3644 let mut status__ = None;
3645 let mut task_id__ = None;
3646 while let Some(k) = map_.next_key()? {
3647 match k {
3648 GeneratedField::Status => {
3649 if status__.is_some() {
3650 return Err(serde::de::Error::duplicate_field("status"));
3651 }
3652 status__ = map_.next_value()?;
3653 }
3654 GeneratedField::TaskId => {
3655 if task_id__.is_some() {
3656 return Err(serde::de::Error::duplicate_field("taskId"));
3657 }
3658 task_id__ =
3659 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3660 ;
3661 }
3662 }
3663 }
3664 Ok(CompactIcebergTableResponse {
3665 status: status__,
3666 task_id: task_id__.unwrap_or_default(),
3667 })
3668 }
3669 }
3670 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
3671 }
3672}
3673impl serde::Serialize for CreateConnectionRequest {
3674 #[allow(deprecated)]
3675 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3676 where
3677 S: serde::Serializer,
3678 {
3679 use serde::ser::SerializeStruct;
3680 let mut len = 0;
3681 if !self.name.is_empty() {
3682 len += 1;
3683 }
3684 if self.database_id != 0 {
3685 len += 1;
3686 }
3687 if self.schema_id != 0 {
3688 len += 1;
3689 }
3690 if self.owner_id != 0 {
3691 len += 1;
3692 }
3693 if self.payload.is_some() {
3694 len += 1;
3695 }
3696 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
3697 if !self.name.is_empty() {
3698 struct_ser.serialize_field("name", &self.name)?;
3699 }
3700 if self.database_id != 0 {
3701 struct_ser.serialize_field("databaseId", &self.database_id)?;
3702 }
3703 if self.schema_id != 0 {
3704 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3705 }
3706 if self.owner_id != 0 {
3707 struct_ser.serialize_field("ownerId", &self.owner_id)?;
3708 }
3709 if let Some(v) = self.payload.as_ref() {
3710 match v {
3711 create_connection_request::Payload::PrivateLink(v) => {
3712 struct_ser.serialize_field("privateLink", v)?;
3713 }
3714 create_connection_request::Payload::ConnectionParams(v) => {
3715 struct_ser.serialize_field("connectionParams", v)?;
3716 }
3717 }
3718 }
3719 struct_ser.end()
3720 }
3721}
3722impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
3723 #[allow(deprecated)]
3724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3725 where
3726 D: serde::Deserializer<'de>,
3727 {
3728 const FIELDS: &[&str] = &[
3729 "name",
3730 "database_id",
3731 "databaseId",
3732 "schema_id",
3733 "schemaId",
3734 "owner_id",
3735 "ownerId",
3736 "private_link",
3737 "privateLink",
3738 "connection_params",
3739 "connectionParams",
3740 ];
3741
3742 #[allow(clippy::enum_variant_names)]
3743 enum GeneratedField {
3744 Name,
3745 DatabaseId,
3746 SchemaId,
3747 OwnerId,
3748 PrivateLink,
3749 ConnectionParams,
3750 }
3751 impl<'de> serde::Deserialize<'de> for GeneratedField {
3752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3753 where
3754 D: serde::Deserializer<'de>,
3755 {
3756 struct GeneratedVisitor;
3757
3758 impl serde::de::Visitor<'_> for GeneratedVisitor {
3759 type Value = GeneratedField;
3760
3761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3762 write!(formatter, "expected one of: {:?}", &FIELDS)
3763 }
3764
3765 #[allow(unused_variables)]
3766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3767 where
3768 E: serde::de::Error,
3769 {
3770 match value {
3771 "name" => Ok(GeneratedField::Name),
3772 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3773 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3774 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
3775 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
3776 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
3777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3778 }
3779 }
3780 }
3781 deserializer.deserialize_identifier(GeneratedVisitor)
3782 }
3783 }
3784 struct GeneratedVisitor;
3785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3786 type Value = CreateConnectionRequest;
3787
3788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3789 formatter.write_str("struct ddl_service.CreateConnectionRequest")
3790 }
3791
3792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
3793 where
3794 V: serde::de::MapAccess<'de>,
3795 {
3796 let mut name__ = None;
3797 let mut database_id__ = None;
3798 let mut schema_id__ = None;
3799 let mut owner_id__ = None;
3800 let mut payload__ = None;
3801 while let Some(k) = map_.next_key()? {
3802 match k {
3803 GeneratedField::Name => {
3804 if name__.is_some() {
3805 return Err(serde::de::Error::duplicate_field("name"));
3806 }
3807 name__ = Some(map_.next_value()?);
3808 }
3809 GeneratedField::DatabaseId => {
3810 if database_id__.is_some() {
3811 return Err(serde::de::Error::duplicate_field("databaseId"));
3812 }
3813 database_id__ =
3814 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3815 ;
3816 }
3817 GeneratedField::SchemaId => {
3818 if schema_id__.is_some() {
3819 return Err(serde::de::Error::duplicate_field("schemaId"));
3820 }
3821 schema_id__ =
3822 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3823 ;
3824 }
3825 GeneratedField::OwnerId => {
3826 if owner_id__.is_some() {
3827 return Err(serde::de::Error::duplicate_field("ownerId"));
3828 }
3829 owner_id__ =
3830 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3831 ;
3832 }
3833 GeneratedField::PrivateLink => {
3834 if payload__.is_some() {
3835 return Err(serde::de::Error::duplicate_field("privateLink"));
3836 }
3837 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
3838;
3839 }
3840 GeneratedField::ConnectionParams => {
3841 if payload__.is_some() {
3842 return Err(serde::de::Error::duplicate_field("connectionParams"));
3843 }
3844 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
3845;
3846 }
3847 }
3848 }
3849 Ok(CreateConnectionRequest {
3850 name: name__.unwrap_or_default(),
3851 database_id: database_id__.unwrap_or_default(),
3852 schema_id: schema_id__.unwrap_or_default(),
3853 owner_id: owner_id__.unwrap_or_default(),
3854 payload: payload__,
3855 })
3856 }
3857 }
3858 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
3859 }
3860}
3861impl serde::Serialize for create_connection_request::PrivateLink {
3862 #[allow(deprecated)]
3863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3864 where
3865 S: serde::Serializer,
3866 {
3867 use serde::ser::SerializeStruct;
3868 let mut len = 0;
3869 if self.provider != 0 {
3870 len += 1;
3871 }
3872 if !self.service_name.is_empty() {
3873 len += 1;
3874 }
3875 if self.tags.is_some() {
3876 len += 1;
3877 }
3878 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
3879 if self.provider != 0 {
3880 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
3881 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
3882 struct_ser.serialize_field("provider", &v)?;
3883 }
3884 if !self.service_name.is_empty() {
3885 struct_ser.serialize_field("serviceName", &self.service_name)?;
3886 }
3887 if let Some(v) = self.tags.as_ref() {
3888 struct_ser.serialize_field("tags", v)?;
3889 }
3890 struct_ser.end()
3891 }
3892}
3893impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
3894 #[allow(deprecated)]
3895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3896 where
3897 D: serde::Deserializer<'de>,
3898 {
3899 const FIELDS: &[&str] = &[
3900 "provider",
3901 "service_name",
3902 "serviceName",
3903 "tags",
3904 ];
3905
3906 #[allow(clippy::enum_variant_names)]
3907 enum GeneratedField {
3908 Provider,
3909 ServiceName,
3910 Tags,
3911 }
3912 impl<'de> serde::Deserialize<'de> for GeneratedField {
3913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3914 where
3915 D: serde::Deserializer<'de>,
3916 {
3917 struct GeneratedVisitor;
3918
3919 impl serde::de::Visitor<'_> for GeneratedVisitor {
3920 type Value = GeneratedField;
3921
3922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3923 write!(formatter, "expected one of: {:?}", &FIELDS)
3924 }
3925
3926 #[allow(unused_variables)]
3927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3928 where
3929 E: serde::de::Error,
3930 {
3931 match value {
3932 "provider" => Ok(GeneratedField::Provider),
3933 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
3934 "tags" => Ok(GeneratedField::Tags),
3935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3936 }
3937 }
3938 }
3939 deserializer.deserialize_identifier(GeneratedVisitor)
3940 }
3941 }
3942 struct GeneratedVisitor;
3943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3944 type Value = create_connection_request::PrivateLink;
3945
3946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3947 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
3948 }
3949
3950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
3951 where
3952 V: serde::de::MapAccess<'de>,
3953 {
3954 let mut provider__ = None;
3955 let mut service_name__ = None;
3956 let mut tags__ = None;
3957 while let Some(k) = map_.next_key()? {
3958 match k {
3959 GeneratedField::Provider => {
3960 if provider__.is_some() {
3961 return Err(serde::de::Error::duplicate_field("provider"));
3962 }
3963 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
3964 }
3965 GeneratedField::ServiceName => {
3966 if service_name__.is_some() {
3967 return Err(serde::de::Error::duplicate_field("serviceName"));
3968 }
3969 service_name__ = Some(map_.next_value()?);
3970 }
3971 GeneratedField::Tags => {
3972 if tags__.is_some() {
3973 return Err(serde::de::Error::duplicate_field("tags"));
3974 }
3975 tags__ = map_.next_value()?;
3976 }
3977 }
3978 }
3979 Ok(create_connection_request::PrivateLink {
3980 provider: provider__.unwrap_or_default(),
3981 service_name: service_name__.unwrap_or_default(),
3982 tags: tags__,
3983 })
3984 }
3985 }
3986 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
3987 }
3988}
3989impl serde::Serialize for CreateConnectionResponse {
3990 #[allow(deprecated)]
3991 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3992 where
3993 S: serde::Serializer,
3994 {
3995 use serde::ser::SerializeStruct;
3996 let mut len = 0;
3997 if self.version.is_some() {
3998 len += 1;
3999 }
4000 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
4001 if let Some(v) = self.version.as_ref() {
4002 struct_ser.serialize_field("version", v)?;
4003 }
4004 struct_ser.end()
4005 }
4006}
4007impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
4008 #[allow(deprecated)]
4009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4010 where
4011 D: serde::Deserializer<'de>,
4012 {
4013 const FIELDS: &[&str] = &[
4014 "version",
4015 ];
4016
4017 #[allow(clippy::enum_variant_names)]
4018 enum GeneratedField {
4019 Version,
4020 }
4021 impl<'de> serde::Deserialize<'de> for GeneratedField {
4022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4023 where
4024 D: serde::Deserializer<'de>,
4025 {
4026 struct GeneratedVisitor;
4027
4028 impl serde::de::Visitor<'_> for GeneratedVisitor {
4029 type Value = GeneratedField;
4030
4031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4032 write!(formatter, "expected one of: {:?}", &FIELDS)
4033 }
4034
4035 #[allow(unused_variables)]
4036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4037 where
4038 E: serde::de::Error,
4039 {
4040 match value {
4041 "version" => Ok(GeneratedField::Version),
4042 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4043 }
4044 }
4045 }
4046 deserializer.deserialize_identifier(GeneratedVisitor)
4047 }
4048 }
4049 struct GeneratedVisitor;
4050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4051 type Value = CreateConnectionResponse;
4052
4053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4054 formatter.write_str("struct ddl_service.CreateConnectionResponse")
4055 }
4056
4057 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
4058 where
4059 V: serde::de::MapAccess<'de>,
4060 {
4061 let mut version__ = None;
4062 while let Some(k) = map_.next_key()? {
4063 match k {
4064 GeneratedField::Version => {
4065 if version__.is_some() {
4066 return Err(serde::de::Error::duplicate_field("version"));
4067 }
4068 version__ = map_.next_value()?;
4069 }
4070 }
4071 }
4072 Ok(CreateConnectionResponse {
4073 version: version__,
4074 })
4075 }
4076 }
4077 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
4078 }
4079}
4080impl serde::Serialize for CreateDatabaseRequest {
4081 #[allow(deprecated)]
4082 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4083 where
4084 S: serde::Serializer,
4085 {
4086 use serde::ser::SerializeStruct;
4087 let mut len = 0;
4088 if self.db.is_some() {
4089 len += 1;
4090 }
4091 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
4092 if let Some(v) = self.db.as_ref() {
4093 struct_ser.serialize_field("db", v)?;
4094 }
4095 struct_ser.end()
4096 }
4097}
4098impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
4099 #[allow(deprecated)]
4100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4101 where
4102 D: serde::Deserializer<'de>,
4103 {
4104 const FIELDS: &[&str] = &[
4105 "db",
4106 ];
4107
4108 #[allow(clippy::enum_variant_names)]
4109 enum GeneratedField {
4110 Db,
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 "db" => Ok(GeneratedField::Db),
4133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4134 }
4135 }
4136 }
4137 deserializer.deserialize_identifier(GeneratedVisitor)
4138 }
4139 }
4140 struct GeneratedVisitor;
4141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4142 type Value = CreateDatabaseRequest;
4143
4144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4145 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
4146 }
4147
4148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
4149 where
4150 V: serde::de::MapAccess<'de>,
4151 {
4152 let mut db__ = None;
4153 while let Some(k) = map_.next_key()? {
4154 match k {
4155 GeneratedField::Db => {
4156 if db__.is_some() {
4157 return Err(serde::de::Error::duplicate_field("db"));
4158 }
4159 db__ = map_.next_value()?;
4160 }
4161 }
4162 }
4163 Ok(CreateDatabaseRequest {
4164 db: db__,
4165 })
4166 }
4167 }
4168 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
4169 }
4170}
4171impl serde::Serialize for CreateDatabaseResponse {
4172 #[allow(deprecated)]
4173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4174 where
4175 S: serde::Serializer,
4176 {
4177 use serde::ser::SerializeStruct;
4178 let mut len = 0;
4179 if self.status.is_some() {
4180 len += 1;
4181 }
4182 if self.version.is_some() {
4183 len += 1;
4184 }
4185 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
4186 if let Some(v) = self.status.as_ref() {
4187 struct_ser.serialize_field("status", v)?;
4188 }
4189 if let Some(v) = self.version.as_ref() {
4190 struct_ser.serialize_field("version", v)?;
4191 }
4192 struct_ser.end()
4193 }
4194}
4195impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
4196 #[allow(deprecated)]
4197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4198 where
4199 D: serde::Deserializer<'de>,
4200 {
4201 const FIELDS: &[&str] = &[
4202 "status",
4203 "version",
4204 ];
4205
4206 #[allow(clippy::enum_variant_names)]
4207 enum GeneratedField {
4208 Status,
4209 Version,
4210 }
4211 impl<'de> serde::Deserialize<'de> for GeneratedField {
4212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4213 where
4214 D: serde::Deserializer<'de>,
4215 {
4216 struct GeneratedVisitor;
4217
4218 impl serde::de::Visitor<'_> for GeneratedVisitor {
4219 type Value = GeneratedField;
4220
4221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4222 write!(formatter, "expected one of: {:?}", &FIELDS)
4223 }
4224
4225 #[allow(unused_variables)]
4226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4227 where
4228 E: serde::de::Error,
4229 {
4230 match value {
4231 "status" => Ok(GeneratedField::Status),
4232 "version" => Ok(GeneratedField::Version),
4233 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4234 }
4235 }
4236 }
4237 deserializer.deserialize_identifier(GeneratedVisitor)
4238 }
4239 }
4240 struct GeneratedVisitor;
4241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4242 type Value = CreateDatabaseResponse;
4243
4244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4245 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
4246 }
4247
4248 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
4249 where
4250 V: serde::de::MapAccess<'de>,
4251 {
4252 let mut status__ = None;
4253 let mut version__ = None;
4254 while let Some(k) = map_.next_key()? {
4255 match k {
4256 GeneratedField::Status => {
4257 if status__.is_some() {
4258 return Err(serde::de::Error::duplicate_field("status"));
4259 }
4260 status__ = map_.next_value()?;
4261 }
4262 GeneratedField::Version => {
4263 if version__.is_some() {
4264 return Err(serde::de::Error::duplicate_field("version"));
4265 }
4266 version__ = map_.next_value()?;
4267 }
4268 }
4269 }
4270 Ok(CreateDatabaseResponse {
4271 status: status__,
4272 version: version__,
4273 })
4274 }
4275 }
4276 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
4277 }
4278}
4279impl serde::Serialize for CreateFunctionRequest {
4280 #[allow(deprecated)]
4281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4282 where
4283 S: serde::Serializer,
4284 {
4285 use serde::ser::SerializeStruct;
4286 let mut len = 0;
4287 if self.function.is_some() {
4288 len += 1;
4289 }
4290 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
4291 if let Some(v) = self.function.as_ref() {
4292 struct_ser.serialize_field("function", v)?;
4293 }
4294 struct_ser.end()
4295 }
4296}
4297impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
4298 #[allow(deprecated)]
4299 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4300 where
4301 D: serde::Deserializer<'de>,
4302 {
4303 const FIELDS: &[&str] = &[
4304 "function",
4305 ];
4306
4307 #[allow(clippy::enum_variant_names)]
4308 enum GeneratedField {
4309 Function,
4310 }
4311 impl<'de> serde::Deserialize<'de> for GeneratedField {
4312 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4313 where
4314 D: serde::Deserializer<'de>,
4315 {
4316 struct GeneratedVisitor;
4317
4318 impl serde::de::Visitor<'_> for GeneratedVisitor {
4319 type Value = GeneratedField;
4320
4321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4322 write!(formatter, "expected one of: {:?}", &FIELDS)
4323 }
4324
4325 #[allow(unused_variables)]
4326 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4327 where
4328 E: serde::de::Error,
4329 {
4330 match value {
4331 "function" => Ok(GeneratedField::Function),
4332 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4333 }
4334 }
4335 }
4336 deserializer.deserialize_identifier(GeneratedVisitor)
4337 }
4338 }
4339 struct GeneratedVisitor;
4340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4341 type Value = CreateFunctionRequest;
4342
4343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4344 formatter.write_str("struct ddl_service.CreateFunctionRequest")
4345 }
4346
4347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
4348 where
4349 V: serde::de::MapAccess<'de>,
4350 {
4351 let mut function__ = None;
4352 while let Some(k) = map_.next_key()? {
4353 match k {
4354 GeneratedField::Function => {
4355 if function__.is_some() {
4356 return Err(serde::de::Error::duplicate_field("function"));
4357 }
4358 function__ = map_.next_value()?;
4359 }
4360 }
4361 }
4362 Ok(CreateFunctionRequest {
4363 function: function__,
4364 })
4365 }
4366 }
4367 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
4368 }
4369}
4370impl serde::Serialize for CreateFunctionResponse {
4371 #[allow(deprecated)]
4372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4373 where
4374 S: serde::Serializer,
4375 {
4376 use serde::ser::SerializeStruct;
4377 let mut len = 0;
4378 if self.status.is_some() {
4379 len += 1;
4380 }
4381 if self.version.is_some() {
4382 len += 1;
4383 }
4384 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
4385 if let Some(v) = self.status.as_ref() {
4386 struct_ser.serialize_field("status", v)?;
4387 }
4388 if let Some(v) = self.version.as_ref() {
4389 struct_ser.serialize_field("version", v)?;
4390 }
4391 struct_ser.end()
4392 }
4393}
4394impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
4395 #[allow(deprecated)]
4396 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4397 where
4398 D: serde::Deserializer<'de>,
4399 {
4400 const FIELDS: &[&str] = &[
4401 "status",
4402 "version",
4403 ];
4404
4405 #[allow(clippy::enum_variant_names)]
4406 enum GeneratedField {
4407 Status,
4408 Version,
4409 }
4410 impl<'de> serde::Deserialize<'de> for GeneratedField {
4411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4412 where
4413 D: serde::Deserializer<'de>,
4414 {
4415 struct GeneratedVisitor;
4416
4417 impl serde::de::Visitor<'_> for GeneratedVisitor {
4418 type Value = GeneratedField;
4419
4420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4421 write!(formatter, "expected one of: {:?}", &FIELDS)
4422 }
4423
4424 #[allow(unused_variables)]
4425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4426 where
4427 E: serde::de::Error,
4428 {
4429 match value {
4430 "status" => Ok(GeneratedField::Status),
4431 "version" => Ok(GeneratedField::Version),
4432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4433 }
4434 }
4435 }
4436 deserializer.deserialize_identifier(GeneratedVisitor)
4437 }
4438 }
4439 struct GeneratedVisitor;
4440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4441 type Value = CreateFunctionResponse;
4442
4443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4444 formatter.write_str("struct ddl_service.CreateFunctionResponse")
4445 }
4446
4447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
4448 where
4449 V: serde::de::MapAccess<'de>,
4450 {
4451 let mut status__ = None;
4452 let mut version__ = None;
4453 while let Some(k) = map_.next_key()? {
4454 match k {
4455 GeneratedField::Status => {
4456 if status__.is_some() {
4457 return Err(serde::de::Error::duplicate_field("status"));
4458 }
4459 status__ = map_.next_value()?;
4460 }
4461 GeneratedField::Version => {
4462 if version__.is_some() {
4463 return Err(serde::de::Error::duplicate_field("version"));
4464 }
4465 version__ = map_.next_value()?;
4466 }
4467 }
4468 }
4469 Ok(CreateFunctionResponse {
4470 status: status__,
4471 version: version__,
4472 })
4473 }
4474 }
4475 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
4476 }
4477}
4478impl serde::Serialize for CreateIcebergTableRequest {
4479 #[allow(deprecated)]
4480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4481 where
4482 S: serde::Serializer,
4483 {
4484 use serde::ser::SerializeStruct;
4485 let mut len = 0;
4486 if self.table_info.is_some() {
4487 len += 1;
4488 }
4489 if self.sink_info.is_some() {
4490 len += 1;
4491 }
4492 if self.iceberg_source.is_some() {
4493 len += 1;
4494 }
4495 if self.if_not_exists {
4496 len += 1;
4497 }
4498 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
4499 if let Some(v) = self.table_info.as_ref() {
4500 struct_ser.serialize_field("tableInfo", v)?;
4501 }
4502 if let Some(v) = self.sink_info.as_ref() {
4503 struct_ser.serialize_field("sinkInfo", v)?;
4504 }
4505 if let Some(v) = self.iceberg_source.as_ref() {
4506 struct_ser.serialize_field("icebergSource", v)?;
4507 }
4508 if self.if_not_exists {
4509 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4510 }
4511 struct_ser.end()
4512 }
4513}
4514impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
4515 #[allow(deprecated)]
4516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4517 where
4518 D: serde::Deserializer<'de>,
4519 {
4520 const FIELDS: &[&str] = &[
4521 "table_info",
4522 "tableInfo",
4523 "sink_info",
4524 "sinkInfo",
4525 "iceberg_source",
4526 "icebergSource",
4527 "if_not_exists",
4528 "ifNotExists",
4529 ];
4530
4531 #[allow(clippy::enum_variant_names)]
4532 enum GeneratedField {
4533 TableInfo,
4534 SinkInfo,
4535 IcebergSource,
4536 IfNotExists,
4537 }
4538 impl<'de> serde::Deserialize<'de> for GeneratedField {
4539 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4540 where
4541 D: serde::Deserializer<'de>,
4542 {
4543 struct GeneratedVisitor;
4544
4545 impl serde::de::Visitor<'_> for GeneratedVisitor {
4546 type Value = GeneratedField;
4547
4548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4549 write!(formatter, "expected one of: {:?}", &FIELDS)
4550 }
4551
4552 #[allow(unused_variables)]
4553 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4554 where
4555 E: serde::de::Error,
4556 {
4557 match value {
4558 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
4559 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
4560 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
4561 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4563 }
4564 }
4565 }
4566 deserializer.deserialize_identifier(GeneratedVisitor)
4567 }
4568 }
4569 struct GeneratedVisitor;
4570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4571 type Value = CreateIcebergTableRequest;
4572
4573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4574 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
4575 }
4576
4577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
4578 where
4579 V: serde::de::MapAccess<'de>,
4580 {
4581 let mut table_info__ = None;
4582 let mut sink_info__ = None;
4583 let mut iceberg_source__ = None;
4584 let mut if_not_exists__ = None;
4585 while let Some(k) = map_.next_key()? {
4586 match k {
4587 GeneratedField::TableInfo => {
4588 if table_info__.is_some() {
4589 return Err(serde::de::Error::duplicate_field("tableInfo"));
4590 }
4591 table_info__ = map_.next_value()?;
4592 }
4593 GeneratedField::SinkInfo => {
4594 if sink_info__.is_some() {
4595 return Err(serde::de::Error::duplicate_field("sinkInfo"));
4596 }
4597 sink_info__ = map_.next_value()?;
4598 }
4599 GeneratedField::IcebergSource => {
4600 if iceberg_source__.is_some() {
4601 return Err(serde::de::Error::duplicate_field("icebergSource"));
4602 }
4603 iceberg_source__ = map_.next_value()?;
4604 }
4605 GeneratedField::IfNotExists => {
4606 if if_not_exists__.is_some() {
4607 return Err(serde::de::Error::duplicate_field("ifNotExists"));
4608 }
4609 if_not_exists__ = Some(map_.next_value()?);
4610 }
4611 }
4612 }
4613 Ok(CreateIcebergTableRequest {
4614 table_info: table_info__,
4615 sink_info: sink_info__,
4616 iceberg_source: iceberg_source__,
4617 if_not_exists: if_not_exists__.unwrap_or_default(),
4618 })
4619 }
4620 }
4621 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
4622 }
4623}
4624impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
4625 #[allow(deprecated)]
4626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4627 where
4628 S: serde::Serializer,
4629 {
4630 use serde::ser::SerializeStruct;
4631 let mut len = 0;
4632 if self.sink.is_some() {
4633 len += 1;
4634 }
4635 if self.fragment_graph.is_some() {
4636 len += 1;
4637 }
4638 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
4639 if let Some(v) = self.sink.as_ref() {
4640 struct_ser.serialize_field("sink", v)?;
4641 }
4642 if let Some(v) = self.fragment_graph.as_ref() {
4643 struct_ser.serialize_field("fragmentGraph", v)?;
4644 }
4645 struct_ser.end()
4646 }
4647}
4648impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
4649 #[allow(deprecated)]
4650 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4651 where
4652 D: serde::Deserializer<'de>,
4653 {
4654 const FIELDS: &[&str] = &[
4655 "sink",
4656 "fragment_graph",
4657 "fragmentGraph",
4658 ];
4659
4660 #[allow(clippy::enum_variant_names)]
4661 enum GeneratedField {
4662 Sink,
4663 FragmentGraph,
4664 }
4665 impl<'de> serde::Deserialize<'de> for GeneratedField {
4666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4667 where
4668 D: serde::Deserializer<'de>,
4669 {
4670 struct GeneratedVisitor;
4671
4672 impl serde::de::Visitor<'_> for GeneratedVisitor {
4673 type Value = GeneratedField;
4674
4675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4676 write!(formatter, "expected one of: {:?}", &FIELDS)
4677 }
4678
4679 #[allow(unused_variables)]
4680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4681 where
4682 E: serde::de::Error,
4683 {
4684 match value {
4685 "sink" => Ok(GeneratedField::Sink),
4686 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4687 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4688 }
4689 }
4690 }
4691 deserializer.deserialize_identifier(GeneratedVisitor)
4692 }
4693 }
4694 struct GeneratedVisitor;
4695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4696 type Value = create_iceberg_table_request::SinkJobInfo;
4697
4698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4699 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
4700 }
4701
4702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
4703 where
4704 V: serde::de::MapAccess<'de>,
4705 {
4706 let mut sink__ = None;
4707 let mut fragment_graph__ = None;
4708 while let Some(k) = map_.next_key()? {
4709 match k {
4710 GeneratedField::Sink => {
4711 if sink__.is_some() {
4712 return Err(serde::de::Error::duplicate_field("sink"));
4713 }
4714 sink__ = map_.next_value()?;
4715 }
4716 GeneratedField::FragmentGraph => {
4717 if fragment_graph__.is_some() {
4718 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4719 }
4720 fragment_graph__ = map_.next_value()?;
4721 }
4722 }
4723 }
4724 Ok(create_iceberg_table_request::SinkJobInfo {
4725 sink: sink__,
4726 fragment_graph: fragment_graph__,
4727 })
4728 }
4729 }
4730 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
4731 }
4732}
4733impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
4734 #[allow(deprecated)]
4735 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4736 where
4737 S: serde::Serializer,
4738 {
4739 use serde::ser::SerializeStruct;
4740 let mut len = 0;
4741 if self.source.is_some() {
4742 len += 1;
4743 }
4744 if self.table.is_some() {
4745 len += 1;
4746 }
4747 if self.fragment_graph.is_some() {
4748 len += 1;
4749 }
4750 if self.job_type != 0 {
4751 len += 1;
4752 }
4753 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
4754 if let Some(v) = self.source.as_ref() {
4755 struct_ser.serialize_field("source", v)?;
4756 }
4757 if let Some(v) = self.table.as_ref() {
4758 struct_ser.serialize_field("table", v)?;
4759 }
4760 if let Some(v) = self.fragment_graph.as_ref() {
4761 struct_ser.serialize_field("fragmentGraph", v)?;
4762 }
4763 if self.job_type != 0 {
4764 let v = TableJobType::try_from(self.job_type)
4765 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
4766 struct_ser.serialize_field("jobType", &v)?;
4767 }
4768 struct_ser.end()
4769 }
4770}
4771impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
4772 #[allow(deprecated)]
4773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4774 where
4775 D: serde::Deserializer<'de>,
4776 {
4777 const FIELDS: &[&str] = &[
4778 "source",
4779 "table",
4780 "fragment_graph",
4781 "fragmentGraph",
4782 "job_type",
4783 "jobType",
4784 ];
4785
4786 #[allow(clippy::enum_variant_names)]
4787 enum GeneratedField {
4788 Source,
4789 Table,
4790 FragmentGraph,
4791 JobType,
4792 }
4793 impl<'de> serde::Deserialize<'de> for GeneratedField {
4794 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4795 where
4796 D: serde::Deserializer<'de>,
4797 {
4798 struct GeneratedVisitor;
4799
4800 impl serde::de::Visitor<'_> for GeneratedVisitor {
4801 type Value = GeneratedField;
4802
4803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4804 write!(formatter, "expected one of: {:?}", &FIELDS)
4805 }
4806
4807 #[allow(unused_variables)]
4808 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4809 where
4810 E: serde::de::Error,
4811 {
4812 match value {
4813 "source" => Ok(GeneratedField::Source),
4814 "table" => Ok(GeneratedField::Table),
4815 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4816 "jobType" | "job_type" => Ok(GeneratedField::JobType),
4817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4818 }
4819 }
4820 }
4821 deserializer.deserialize_identifier(GeneratedVisitor)
4822 }
4823 }
4824 struct GeneratedVisitor;
4825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4826 type Value = create_iceberg_table_request::TableJobInfo;
4827
4828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4829 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
4830 }
4831
4832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
4833 where
4834 V: serde::de::MapAccess<'de>,
4835 {
4836 let mut source__ = None;
4837 let mut table__ = None;
4838 let mut fragment_graph__ = None;
4839 let mut job_type__ = None;
4840 while let Some(k) = map_.next_key()? {
4841 match k {
4842 GeneratedField::Source => {
4843 if source__.is_some() {
4844 return Err(serde::de::Error::duplicate_field("source"));
4845 }
4846 source__ = map_.next_value()?;
4847 }
4848 GeneratedField::Table => {
4849 if table__.is_some() {
4850 return Err(serde::de::Error::duplicate_field("table"));
4851 }
4852 table__ = map_.next_value()?;
4853 }
4854 GeneratedField::FragmentGraph => {
4855 if fragment_graph__.is_some() {
4856 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4857 }
4858 fragment_graph__ = map_.next_value()?;
4859 }
4860 GeneratedField::JobType => {
4861 if job_type__.is_some() {
4862 return Err(serde::de::Error::duplicate_field("jobType"));
4863 }
4864 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
4865 }
4866 }
4867 }
4868 Ok(create_iceberg_table_request::TableJobInfo {
4869 source: source__,
4870 table: table__,
4871 fragment_graph: fragment_graph__,
4872 job_type: job_type__.unwrap_or_default(),
4873 })
4874 }
4875 }
4876 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
4877 }
4878}
4879impl serde::Serialize for CreateIcebergTableResponse {
4880 #[allow(deprecated)]
4881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4882 where
4883 S: serde::Serializer,
4884 {
4885 use serde::ser::SerializeStruct;
4886 let mut len = 0;
4887 if self.status.is_some() {
4888 len += 1;
4889 }
4890 if self.version.is_some() {
4891 len += 1;
4892 }
4893 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
4894 if let Some(v) = self.status.as_ref() {
4895 struct_ser.serialize_field("status", v)?;
4896 }
4897 if let Some(v) = self.version.as_ref() {
4898 struct_ser.serialize_field("version", v)?;
4899 }
4900 struct_ser.end()
4901 }
4902}
4903impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
4904 #[allow(deprecated)]
4905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4906 where
4907 D: serde::Deserializer<'de>,
4908 {
4909 const FIELDS: &[&str] = &[
4910 "status",
4911 "version",
4912 ];
4913
4914 #[allow(clippy::enum_variant_names)]
4915 enum GeneratedField {
4916 Status,
4917 Version,
4918 }
4919 impl<'de> serde::Deserialize<'de> for GeneratedField {
4920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4921 where
4922 D: serde::Deserializer<'de>,
4923 {
4924 struct GeneratedVisitor;
4925
4926 impl serde::de::Visitor<'_> for GeneratedVisitor {
4927 type Value = GeneratedField;
4928
4929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4930 write!(formatter, "expected one of: {:?}", &FIELDS)
4931 }
4932
4933 #[allow(unused_variables)]
4934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4935 where
4936 E: serde::de::Error,
4937 {
4938 match value {
4939 "status" => Ok(GeneratedField::Status),
4940 "version" => Ok(GeneratedField::Version),
4941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4942 }
4943 }
4944 }
4945 deserializer.deserialize_identifier(GeneratedVisitor)
4946 }
4947 }
4948 struct GeneratedVisitor;
4949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4950 type Value = CreateIcebergTableResponse;
4951
4952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4953 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
4954 }
4955
4956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
4957 where
4958 V: serde::de::MapAccess<'de>,
4959 {
4960 let mut status__ = None;
4961 let mut version__ = None;
4962 while let Some(k) = map_.next_key()? {
4963 match k {
4964 GeneratedField::Status => {
4965 if status__.is_some() {
4966 return Err(serde::de::Error::duplicate_field("status"));
4967 }
4968 status__ = map_.next_value()?;
4969 }
4970 GeneratedField::Version => {
4971 if version__.is_some() {
4972 return Err(serde::de::Error::duplicate_field("version"));
4973 }
4974 version__ = map_.next_value()?;
4975 }
4976 }
4977 }
4978 Ok(CreateIcebergTableResponse {
4979 status: status__,
4980 version: version__,
4981 })
4982 }
4983 }
4984 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
4985 }
4986}
4987impl serde::Serialize for CreateIndexRequest {
4988 #[allow(deprecated)]
4989 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4990 where
4991 S: serde::Serializer,
4992 {
4993 use serde::ser::SerializeStruct;
4994 let mut len = 0;
4995 if self.index.is_some() {
4996 len += 1;
4997 }
4998 if self.index_table.is_some() {
4999 len += 1;
5000 }
5001 if self.fragment_graph.is_some() {
5002 len += 1;
5003 }
5004 if self.if_not_exists {
5005 len += 1;
5006 }
5007 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
5008 if let Some(v) = self.index.as_ref() {
5009 struct_ser.serialize_field("index", v)?;
5010 }
5011 if let Some(v) = self.index_table.as_ref() {
5012 struct_ser.serialize_field("indexTable", v)?;
5013 }
5014 if let Some(v) = self.fragment_graph.as_ref() {
5015 struct_ser.serialize_field("fragmentGraph", v)?;
5016 }
5017 if self.if_not_exists {
5018 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5019 }
5020 struct_ser.end()
5021 }
5022}
5023impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
5024 #[allow(deprecated)]
5025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5026 where
5027 D: serde::Deserializer<'de>,
5028 {
5029 const FIELDS: &[&str] = &[
5030 "index",
5031 "index_table",
5032 "indexTable",
5033 "fragment_graph",
5034 "fragmentGraph",
5035 "if_not_exists",
5036 "ifNotExists",
5037 ];
5038
5039 #[allow(clippy::enum_variant_names)]
5040 enum GeneratedField {
5041 Index,
5042 IndexTable,
5043 FragmentGraph,
5044 IfNotExists,
5045 }
5046 impl<'de> serde::Deserialize<'de> for GeneratedField {
5047 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5048 where
5049 D: serde::Deserializer<'de>,
5050 {
5051 struct GeneratedVisitor;
5052
5053 impl serde::de::Visitor<'_> for GeneratedVisitor {
5054 type Value = GeneratedField;
5055
5056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5057 write!(formatter, "expected one of: {:?}", &FIELDS)
5058 }
5059
5060 #[allow(unused_variables)]
5061 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5062 where
5063 E: serde::de::Error,
5064 {
5065 match value {
5066 "index" => Ok(GeneratedField::Index),
5067 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
5068 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5069 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5070 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5071 }
5072 }
5073 }
5074 deserializer.deserialize_identifier(GeneratedVisitor)
5075 }
5076 }
5077 struct GeneratedVisitor;
5078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5079 type Value = CreateIndexRequest;
5080
5081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5082 formatter.write_str("struct ddl_service.CreateIndexRequest")
5083 }
5084
5085 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
5086 where
5087 V: serde::de::MapAccess<'de>,
5088 {
5089 let mut index__ = None;
5090 let mut index_table__ = None;
5091 let mut fragment_graph__ = None;
5092 let mut if_not_exists__ = None;
5093 while let Some(k) = map_.next_key()? {
5094 match k {
5095 GeneratedField::Index => {
5096 if index__.is_some() {
5097 return Err(serde::de::Error::duplicate_field("index"));
5098 }
5099 index__ = map_.next_value()?;
5100 }
5101 GeneratedField::IndexTable => {
5102 if index_table__.is_some() {
5103 return Err(serde::de::Error::duplicate_field("indexTable"));
5104 }
5105 index_table__ = map_.next_value()?;
5106 }
5107 GeneratedField::FragmentGraph => {
5108 if fragment_graph__.is_some() {
5109 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5110 }
5111 fragment_graph__ = map_.next_value()?;
5112 }
5113 GeneratedField::IfNotExists => {
5114 if if_not_exists__.is_some() {
5115 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5116 }
5117 if_not_exists__ = Some(map_.next_value()?);
5118 }
5119 }
5120 }
5121 Ok(CreateIndexRequest {
5122 index: index__,
5123 index_table: index_table__,
5124 fragment_graph: fragment_graph__,
5125 if_not_exists: if_not_exists__.unwrap_or_default(),
5126 })
5127 }
5128 }
5129 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
5130 }
5131}
5132impl serde::Serialize for CreateIndexResponse {
5133 #[allow(deprecated)]
5134 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5135 where
5136 S: serde::Serializer,
5137 {
5138 use serde::ser::SerializeStruct;
5139 let mut len = 0;
5140 if self.status.is_some() {
5141 len += 1;
5142 }
5143 if self.version.is_some() {
5144 len += 1;
5145 }
5146 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
5147 if let Some(v) = self.status.as_ref() {
5148 struct_ser.serialize_field("status", v)?;
5149 }
5150 if let Some(v) = self.version.as_ref() {
5151 struct_ser.serialize_field("version", v)?;
5152 }
5153 struct_ser.end()
5154 }
5155}
5156impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
5157 #[allow(deprecated)]
5158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5159 where
5160 D: serde::Deserializer<'de>,
5161 {
5162 const FIELDS: &[&str] = &[
5163 "status",
5164 "version",
5165 ];
5166
5167 #[allow(clippy::enum_variant_names)]
5168 enum GeneratedField {
5169 Status,
5170 Version,
5171 }
5172 impl<'de> serde::Deserialize<'de> for GeneratedField {
5173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5174 where
5175 D: serde::Deserializer<'de>,
5176 {
5177 struct GeneratedVisitor;
5178
5179 impl serde::de::Visitor<'_> for GeneratedVisitor {
5180 type Value = GeneratedField;
5181
5182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5183 write!(formatter, "expected one of: {:?}", &FIELDS)
5184 }
5185
5186 #[allow(unused_variables)]
5187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5188 where
5189 E: serde::de::Error,
5190 {
5191 match value {
5192 "status" => Ok(GeneratedField::Status),
5193 "version" => Ok(GeneratedField::Version),
5194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5195 }
5196 }
5197 }
5198 deserializer.deserialize_identifier(GeneratedVisitor)
5199 }
5200 }
5201 struct GeneratedVisitor;
5202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5203 type Value = CreateIndexResponse;
5204
5205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5206 formatter.write_str("struct ddl_service.CreateIndexResponse")
5207 }
5208
5209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
5210 where
5211 V: serde::de::MapAccess<'de>,
5212 {
5213 let mut status__ = None;
5214 let mut version__ = None;
5215 while let Some(k) = map_.next_key()? {
5216 match k {
5217 GeneratedField::Status => {
5218 if status__.is_some() {
5219 return Err(serde::de::Error::duplicate_field("status"));
5220 }
5221 status__ = map_.next_value()?;
5222 }
5223 GeneratedField::Version => {
5224 if version__.is_some() {
5225 return Err(serde::de::Error::duplicate_field("version"));
5226 }
5227 version__ = map_.next_value()?;
5228 }
5229 }
5230 }
5231 Ok(CreateIndexResponse {
5232 status: status__,
5233 version: version__,
5234 })
5235 }
5236 }
5237 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
5238 }
5239}
5240impl serde::Serialize for CreateMaterializedViewRequest {
5241 #[allow(deprecated)]
5242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5243 where
5244 S: serde::Serializer,
5245 {
5246 use serde::ser::SerializeStruct;
5247 let mut len = 0;
5248 if self.materialized_view.is_some() {
5249 len += 1;
5250 }
5251 if self.fragment_graph.is_some() {
5252 len += 1;
5253 }
5254 if self.resource_type.is_some() {
5255 len += 1;
5256 }
5257 if !self.dependencies.is_empty() {
5258 len += 1;
5259 }
5260 if self.if_not_exists {
5261 len += 1;
5262 }
5263 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
5264 if let Some(v) = self.materialized_view.as_ref() {
5265 struct_ser.serialize_field("materializedView", v)?;
5266 }
5267 if let Some(v) = self.fragment_graph.as_ref() {
5268 struct_ser.serialize_field("fragmentGraph", v)?;
5269 }
5270 if let Some(v) = self.resource_type.as_ref() {
5271 struct_ser.serialize_field("resourceType", v)?;
5272 }
5273 if !self.dependencies.is_empty() {
5274 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5275 }
5276 if self.if_not_exists {
5277 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5278 }
5279 struct_ser.end()
5280 }
5281}
5282impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
5283 #[allow(deprecated)]
5284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5285 where
5286 D: serde::Deserializer<'de>,
5287 {
5288 const FIELDS: &[&str] = &[
5289 "materialized_view",
5290 "materializedView",
5291 "fragment_graph",
5292 "fragmentGraph",
5293 "resource_type",
5294 "resourceType",
5295 "dependencies",
5296 "if_not_exists",
5297 "ifNotExists",
5298 ];
5299
5300 #[allow(clippy::enum_variant_names)]
5301 enum GeneratedField {
5302 MaterializedView,
5303 FragmentGraph,
5304 ResourceType,
5305 Dependencies,
5306 IfNotExists,
5307 }
5308 impl<'de> serde::Deserialize<'de> for GeneratedField {
5309 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5310 where
5311 D: serde::Deserializer<'de>,
5312 {
5313 struct GeneratedVisitor;
5314
5315 impl serde::de::Visitor<'_> for GeneratedVisitor {
5316 type Value = GeneratedField;
5317
5318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5319 write!(formatter, "expected one of: {:?}", &FIELDS)
5320 }
5321
5322 #[allow(unused_variables)]
5323 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5324 where
5325 E: serde::de::Error,
5326 {
5327 match value {
5328 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5329 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5330 "resourceType" | "resource_type" => Ok(GeneratedField::ResourceType),
5331 "dependencies" => Ok(GeneratedField::Dependencies),
5332 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5334 }
5335 }
5336 }
5337 deserializer.deserialize_identifier(GeneratedVisitor)
5338 }
5339 }
5340 struct GeneratedVisitor;
5341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5342 type Value = CreateMaterializedViewRequest;
5343
5344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5345 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
5346 }
5347
5348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
5349 where
5350 V: serde::de::MapAccess<'de>,
5351 {
5352 let mut materialized_view__ = None;
5353 let mut fragment_graph__ = None;
5354 let mut resource_type__ = None;
5355 let mut dependencies__ = None;
5356 let mut if_not_exists__ = None;
5357 while let Some(k) = map_.next_key()? {
5358 match k {
5359 GeneratedField::MaterializedView => {
5360 if materialized_view__.is_some() {
5361 return Err(serde::de::Error::duplicate_field("materializedView"));
5362 }
5363 materialized_view__ = map_.next_value()?;
5364 }
5365 GeneratedField::FragmentGraph => {
5366 if fragment_graph__.is_some() {
5367 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5368 }
5369 fragment_graph__ = map_.next_value()?;
5370 }
5371 GeneratedField::ResourceType => {
5372 if resource_type__.is_some() {
5373 return Err(serde::de::Error::duplicate_field("resourceType"));
5374 }
5375 resource_type__ = map_.next_value()?;
5376 }
5377 GeneratedField::Dependencies => {
5378 if dependencies__.is_some() {
5379 return Err(serde::de::Error::duplicate_field("dependencies"));
5380 }
5381 dependencies__ =
5382 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5383 .into_iter().map(|x| x.0).collect())
5384 ;
5385 }
5386 GeneratedField::IfNotExists => {
5387 if if_not_exists__.is_some() {
5388 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5389 }
5390 if_not_exists__ = Some(map_.next_value()?);
5391 }
5392 }
5393 }
5394 Ok(CreateMaterializedViewRequest {
5395 materialized_view: materialized_view__,
5396 fragment_graph: fragment_graph__,
5397 resource_type: resource_type__,
5398 dependencies: dependencies__.unwrap_or_default(),
5399 if_not_exists: if_not_exists__.unwrap_or_default(),
5400 })
5401 }
5402 }
5403 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
5404 }
5405}
5406impl serde::Serialize for CreateMaterializedViewResponse {
5407 #[allow(deprecated)]
5408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5409 where
5410 S: serde::Serializer,
5411 {
5412 use serde::ser::SerializeStruct;
5413 let mut len = 0;
5414 if self.status.is_some() {
5415 len += 1;
5416 }
5417 if self.version.is_some() {
5418 len += 1;
5419 }
5420 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
5421 if let Some(v) = self.status.as_ref() {
5422 struct_ser.serialize_field("status", v)?;
5423 }
5424 if let Some(v) = self.version.as_ref() {
5425 struct_ser.serialize_field("version", v)?;
5426 }
5427 struct_ser.end()
5428 }
5429}
5430impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
5431 #[allow(deprecated)]
5432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5433 where
5434 D: serde::Deserializer<'de>,
5435 {
5436 const FIELDS: &[&str] = &[
5437 "status",
5438 "version",
5439 ];
5440
5441 #[allow(clippy::enum_variant_names)]
5442 enum GeneratedField {
5443 Status,
5444 Version,
5445 }
5446 impl<'de> serde::Deserialize<'de> for GeneratedField {
5447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5448 where
5449 D: serde::Deserializer<'de>,
5450 {
5451 struct GeneratedVisitor;
5452
5453 impl serde::de::Visitor<'_> for GeneratedVisitor {
5454 type Value = GeneratedField;
5455
5456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5457 write!(formatter, "expected one of: {:?}", &FIELDS)
5458 }
5459
5460 #[allow(unused_variables)]
5461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5462 where
5463 E: serde::de::Error,
5464 {
5465 match value {
5466 "status" => Ok(GeneratedField::Status),
5467 "version" => Ok(GeneratedField::Version),
5468 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5469 }
5470 }
5471 }
5472 deserializer.deserialize_identifier(GeneratedVisitor)
5473 }
5474 }
5475 struct GeneratedVisitor;
5476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5477 type Value = CreateMaterializedViewResponse;
5478
5479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5480 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
5481 }
5482
5483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
5484 where
5485 V: serde::de::MapAccess<'de>,
5486 {
5487 let mut status__ = None;
5488 let mut version__ = None;
5489 while let Some(k) = map_.next_key()? {
5490 match k {
5491 GeneratedField::Status => {
5492 if status__.is_some() {
5493 return Err(serde::de::Error::duplicate_field("status"));
5494 }
5495 status__ = map_.next_value()?;
5496 }
5497 GeneratedField::Version => {
5498 if version__.is_some() {
5499 return Err(serde::de::Error::duplicate_field("version"));
5500 }
5501 version__ = map_.next_value()?;
5502 }
5503 }
5504 }
5505 Ok(CreateMaterializedViewResponse {
5506 status: status__,
5507 version: version__,
5508 })
5509 }
5510 }
5511 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
5512 }
5513}
5514impl serde::Serialize for CreateSchemaRequest {
5515 #[allow(deprecated)]
5516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5517 where
5518 S: serde::Serializer,
5519 {
5520 use serde::ser::SerializeStruct;
5521 let mut len = 0;
5522 if self.schema.is_some() {
5523 len += 1;
5524 }
5525 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
5526 if let Some(v) = self.schema.as_ref() {
5527 struct_ser.serialize_field("schema", v)?;
5528 }
5529 struct_ser.end()
5530 }
5531}
5532impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
5533 #[allow(deprecated)]
5534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5535 where
5536 D: serde::Deserializer<'de>,
5537 {
5538 const FIELDS: &[&str] = &[
5539 "schema",
5540 ];
5541
5542 #[allow(clippy::enum_variant_names)]
5543 enum GeneratedField {
5544 Schema,
5545 }
5546 impl<'de> serde::Deserialize<'de> for GeneratedField {
5547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5548 where
5549 D: serde::Deserializer<'de>,
5550 {
5551 struct GeneratedVisitor;
5552
5553 impl serde::de::Visitor<'_> for GeneratedVisitor {
5554 type Value = GeneratedField;
5555
5556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5557 write!(formatter, "expected one of: {:?}", &FIELDS)
5558 }
5559
5560 #[allow(unused_variables)]
5561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5562 where
5563 E: serde::de::Error,
5564 {
5565 match value {
5566 "schema" => Ok(GeneratedField::Schema),
5567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5568 }
5569 }
5570 }
5571 deserializer.deserialize_identifier(GeneratedVisitor)
5572 }
5573 }
5574 struct GeneratedVisitor;
5575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5576 type Value = CreateSchemaRequest;
5577
5578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5579 formatter.write_str("struct ddl_service.CreateSchemaRequest")
5580 }
5581
5582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
5583 where
5584 V: serde::de::MapAccess<'de>,
5585 {
5586 let mut schema__ = None;
5587 while let Some(k) = map_.next_key()? {
5588 match k {
5589 GeneratedField::Schema => {
5590 if schema__.is_some() {
5591 return Err(serde::de::Error::duplicate_field("schema"));
5592 }
5593 schema__ = map_.next_value()?;
5594 }
5595 }
5596 }
5597 Ok(CreateSchemaRequest {
5598 schema: schema__,
5599 })
5600 }
5601 }
5602 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
5603 }
5604}
5605impl serde::Serialize for CreateSchemaResponse {
5606 #[allow(deprecated)]
5607 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5608 where
5609 S: serde::Serializer,
5610 {
5611 use serde::ser::SerializeStruct;
5612 let mut len = 0;
5613 if self.status.is_some() {
5614 len += 1;
5615 }
5616 if self.version.is_some() {
5617 len += 1;
5618 }
5619 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
5620 if let Some(v) = self.status.as_ref() {
5621 struct_ser.serialize_field("status", v)?;
5622 }
5623 if let Some(v) = self.version.as_ref() {
5624 struct_ser.serialize_field("version", v)?;
5625 }
5626 struct_ser.end()
5627 }
5628}
5629impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
5630 #[allow(deprecated)]
5631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5632 where
5633 D: serde::Deserializer<'de>,
5634 {
5635 const FIELDS: &[&str] = &[
5636 "status",
5637 "version",
5638 ];
5639
5640 #[allow(clippy::enum_variant_names)]
5641 enum GeneratedField {
5642 Status,
5643 Version,
5644 }
5645 impl<'de> serde::Deserialize<'de> for GeneratedField {
5646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5647 where
5648 D: serde::Deserializer<'de>,
5649 {
5650 struct GeneratedVisitor;
5651
5652 impl serde::de::Visitor<'_> for GeneratedVisitor {
5653 type Value = GeneratedField;
5654
5655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5656 write!(formatter, "expected one of: {:?}", &FIELDS)
5657 }
5658
5659 #[allow(unused_variables)]
5660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5661 where
5662 E: serde::de::Error,
5663 {
5664 match value {
5665 "status" => Ok(GeneratedField::Status),
5666 "version" => Ok(GeneratedField::Version),
5667 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5668 }
5669 }
5670 }
5671 deserializer.deserialize_identifier(GeneratedVisitor)
5672 }
5673 }
5674 struct GeneratedVisitor;
5675 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5676 type Value = CreateSchemaResponse;
5677
5678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5679 formatter.write_str("struct ddl_service.CreateSchemaResponse")
5680 }
5681
5682 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
5683 where
5684 V: serde::de::MapAccess<'de>,
5685 {
5686 let mut status__ = None;
5687 let mut version__ = None;
5688 while let Some(k) = map_.next_key()? {
5689 match k {
5690 GeneratedField::Status => {
5691 if status__.is_some() {
5692 return Err(serde::de::Error::duplicate_field("status"));
5693 }
5694 status__ = map_.next_value()?;
5695 }
5696 GeneratedField::Version => {
5697 if version__.is_some() {
5698 return Err(serde::de::Error::duplicate_field("version"));
5699 }
5700 version__ = map_.next_value()?;
5701 }
5702 }
5703 }
5704 Ok(CreateSchemaResponse {
5705 status: status__,
5706 version: version__,
5707 })
5708 }
5709 }
5710 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
5711 }
5712}
5713impl serde::Serialize for CreateSecretRequest {
5714 #[allow(deprecated)]
5715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5716 where
5717 S: serde::Serializer,
5718 {
5719 use serde::ser::SerializeStruct;
5720 let mut len = 0;
5721 if !self.name.is_empty() {
5722 len += 1;
5723 }
5724 if !self.value.is_empty() {
5725 len += 1;
5726 }
5727 if self.database_id != 0 {
5728 len += 1;
5729 }
5730 if self.schema_id != 0 {
5731 len += 1;
5732 }
5733 if self.owner_id != 0 {
5734 len += 1;
5735 }
5736 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
5737 if !self.name.is_empty() {
5738 struct_ser.serialize_field("name", &self.name)?;
5739 }
5740 if !self.value.is_empty() {
5741 #[allow(clippy::needless_borrow)]
5742 #[allow(clippy::needless_borrows_for_generic_args)]
5743 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
5744 }
5745 if self.database_id != 0 {
5746 struct_ser.serialize_field("databaseId", &self.database_id)?;
5747 }
5748 if self.schema_id != 0 {
5749 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5750 }
5751 if self.owner_id != 0 {
5752 struct_ser.serialize_field("ownerId", &self.owner_id)?;
5753 }
5754 struct_ser.end()
5755 }
5756}
5757impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
5758 #[allow(deprecated)]
5759 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5760 where
5761 D: serde::Deserializer<'de>,
5762 {
5763 const FIELDS: &[&str] = &[
5764 "name",
5765 "value",
5766 "database_id",
5767 "databaseId",
5768 "schema_id",
5769 "schemaId",
5770 "owner_id",
5771 "ownerId",
5772 ];
5773
5774 #[allow(clippy::enum_variant_names)]
5775 enum GeneratedField {
5776 Name,
5777 Value,
5778 DatabaseId,
5779 SchemaId,
5780 OwnerId,
5781 }
5782 impl<'de> serde::Deserialize<'de> for GeneratedField {
5783 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5784 where
5785 D: serde::Deserializer<'de>,
5786 {
5787 struct GeneratedVisitor;
5788
5789 impl serde::de::Visitor<'_> for GeneratedVisitor {
5790 type Value = GeneratedField;
5791
5792 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5793 write!(formatter, "expected one of: {:?}", &FIELDS)
5794 }
5795
5796 #[allow(unused_variables)]
5797 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5798 where
5799 E: serde::de::Error,
5800 {
5801 match value {
5802 "name" => Ok(GeneratedField::Name),
5803 "value" => Ok(GeneratedField::Value),
5804 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5805 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5806 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
5807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5808 }
5809 }
5810 }
5811 deserializer.deserialize_identifier(GeneratedVisitor)
5812 }
5813 }
5814 struct GeneratedVisitor;
5815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5816 type Value = CreateSecretRequest;
5817
5818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5819 formatter.write_str("struct ddl_service.CreateSecretRequest")
5820 }
5821
5822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
5823 where
5824 V: serde::de::MapAccess<'de>,
5825 {
5826 let mut name__ = None;
5827 let mut value__ = None;
5828 let mut database_id__ = None;
5829 let mut schema_id__ = None;
5830 let mut owner_id__ = None;
5831 while let Some(k) = map_.next_key()? {
5832 match k {
5833 GeneratedField::Name => {
5834 if name__.is_some() {
5835 return Err(serde::de::Error::duplicate_field("name"));
5836 }
5837 name__ = Some(map_.next_value()?);
5838 }
5839 GeneratedField::Value => {
5840 if value__.is_some() {
5841 return Err(serde::de::Error::duplicate_field("value"));
5842 }
5843 value__ =
5844 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
5845 ;
5846 }
5847 GeneratedField::DatabaseId => {
5848 if database_id__.is_some() {
5849 return Err(serde::de::Error::duplicate_field("databaseId"));
5850 }
5851 database_id__ =
5852 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5853 ;
5854 }
5855 GeneratedField::SchemaId => {
5856 if schema_id__.is_some() {
5857 return Err(serde::de::Error::duplicate_field("schemaId"));
5858 }
5859 schema_id__ =
5860 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5861 ;
5862 }
5863 GeneratedField::OwnerId => {
5864 if owner_id__.is_some() {
5865 return Err(serde::de::Error::duplicate_field("ownerId"));
5866 }
5867 owner_id__ =
5868 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5869 ;
5870 }
5871 }
5872 }
5873 Ok(CreateSecretRequest {
5874 name: name__.unwrap_or_default(),
5875 value: value__.unwrap_or_default(),
5876 database_id: database_id__.unwrap_or_default(),
5877 schema_id: schema_id__.unwrap_or_default(),
5878 owner_id: owner_id__.unwrap_or_default(),
5879 })
5880 }
5881 }
5882 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
5883 }
5884}
5885impl serde::Serialize for CreateSecretResponse {
5886 #[allow(deprecated)]
5887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5888 where
5889 S: serde::Serializer,
5890 {
5891 use serde::ser::SerializeStruct;
5892 let mut len = 0;
5893 if self.version.is_some() {
5894 len += 1;
5895 }
5896 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
5897 if let Some(v) = self.version.as_ref() {
5898 struct_ser.serialize_field("version", v)?;
5899 }
5900 struct_ser.end()
5901 }
5902}
5903impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
5904 #[allow(deprecated)]
5905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5906 where
5907 D: serde::Deserializer<'de>,
5908 {
5909 const FIELDS: &[&str] = &[
5910 "version",
5911 ];
5912
5913 #[allow(clippy::enum_variant_names)]
5914 enum GeneratedField {
5915 Version,
5916 }
5917 impl<'de> serde::Deserialize<'de> for GeneratedField {
5918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5919 where
5920 D: serde::Deserializer<'de>,
5921 {
5922 struct GeneratedVisitor;
5923
5924 impl serde::de::Visitor<'_> for GeneratedVisitor {
5925 type Value = GeneratedField;
5926
5927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5928 write!(formatter, "expected one of: {:?}", &FIELDS)
5929 }
5930
5931 #[allow(unused_variables)]
5932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5933 where
5934 E: serde::de::Error,
5935 {
5936 match value {
5937 "version" => Ok(GeneratedField::Version),
5938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5939 }
5940 }
5941 }
5942 deserializer.deserialize_identifier(GeneratedVisitor)
5943 }
5944 }
5945 struct GeneratedVisitor;
5946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5947 type Value = CreateSecretResponse;
5948
5949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5950 formatter.write_str("struct ddl_service.CreateSecretResponse")
5951 }
5952
5953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
5954 where
5955 V: serde::de::MapAccess<'de>,
5956 {
5957 let mut version__ = None;
5958 while let Some(k) = map_.next_key()? {
5959 match k {
5960 GeneratedField::Version => {
5961 if version__.is_some() {
5962 return Err(serde::de::Error::duplicate_field("version"));
5963 }
5964 version__ = map_.next_value()?;
5965 }
5966 }
5967 }
5968 Ok(CreateSecretResponse {
5969 version: version__,
5970 })
5971 }
5972 }
5973 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
5974 }
5975}
5976impl serde::Serialize for CreateSinkRequest {
5977 #[allow(deprecated)]
5978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5979 where
5980 S: serde::Serializer,
5981 {
5982 use serde::ser::SerializeStruct;
5983 let mut len = 0;
5984 if self.sink.is_some() {
5985 len += 1;
5986 }
5987 if self.fragment_graph.is_some() {
5988 len += 1;
5989 }
5990 if !self.dependencies.is_empty() {
5991 len += 1;
5992 }
5993 if self.if_not_exists {
5994 len += 1;
5995 }
5996 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
5997 if let Some(v) = self.sink.as_ref() {
5998 struct_ser.serialize_field("sink", v)?;
5999 }
6000 if let Some(v) = self.fragment_graph.as_ref() {
6001 struct_ser.serialize_field("fragmentGraph", v)?;
6002 }
6003 if !self.dependencies.is_empty() {
6004 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6005 }
6006 if self.if_not_exists {
6007 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6008 }
6009 struct_ser.end()
6010 }
6011}
6012impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6013 #[allow(deprecated)]
6014 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6015 where
6016 D: serde::Deserializer<'de>,
6017 {
6018 const FIELDS: &[&str] = &[
6019 "sink",
6020 "fragment_graph",
6021 "fragmentGraph",
6022 "dependencies",
6023 "if_not_exists",
6024 "ifNotExists",
6025 ];
6026
6027 #[allow(clippy::enum_variant_names)]
6028 enum GeneratedField {
6029 Sink,
6030 FragmentGraph,
6031 Dependencies,
6032 IfNotExists,
6033 }
6034 impl<'de> serde::Deserialize<'de> for GeneratedField {
6035 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6036 where
6037 D: serde::Deserializer<'de>,
6038 {
6039 struct GeneratedVisitor;
6040
6041 impl serde::de::Visitor<'_> for GeneratedVisitor {
6042 type Value = GeneratedField;
6043
6044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6045 write!(formatter, "expected one of: {:?}", &FIELDS)
6046 }
6047
6048 #[allow(unused_variables)]
6049 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6050 where
6051 E: serde::de::Error,
6052 {
6053 match value {
6054 "sink" => Ok(GeneratedField::Sink),
6055 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6056 "dependencies" => Ok(GeneratedField::Dependencies),
6057 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6059 }
6060 }
6061 }
6062 deserializer.deserialize_identifier(GeneratedVisitor)
6063 }
6064 }
6065 struct GeneratedVisitor;
6066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6067 type Value = CreateSinkRequest;
6068
6069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6070 formatter.write_str("struct ddl_service.CreateSinkRequest")
6071 }
6072
6073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6074 where
6075 V: serde::de::MapAccess<'de>,
6076 {
6077 let mut sink__ = None;
6078 let mut fragment_graph__ = None;
6079 let mut dependencies__ = None;
6080 let mut if_not_exists__ = None;
6081 while let Some(k) = map_.next_key()? {
6082 match k {
6083 GeneratedField::Sink => {
6084 if sink__.is_some() {
6085 return Err(serde::de::Error::duplicate_field("sink"));
6086 }
6087 sink__ = map_.next_value()?;
6088 }
6089 GeneratedField::FragmentGraph => {
6090 if fragment_graph__.is_some() {
6091 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6092 }
6093 fragment_graph__ = map_.next_value()?;
6094 }
6095 GeneratedField::Dependencies => {
6096 if dependencies__.is_some() {
6097 return Err(serde::de::Error::duplicate_field("dependencies"));
6098 }
6099 dependencies__ =
6100 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6101 .into_iter().map(|x| x.0).collect())
6102 ;
6103 }
6104 GeneratedField::IfNotExists => {
6105 if if_not_exists__.is_some() {
6106 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6107 }
6108 if_not_exists__ = Some(map_.next_value()?);
6109 }
6110 }
6111 }
6112 Ok(CreateSinkRequest {
6113 sink: sink__,
6114 fragment_graph: fragment_graph__,
6115 dependencies: dependencies__.unwrap_or_default(),
6116 if_not_exists: if_not_exists__.unwrap_or_default(),
6117 })
6118 }
6119 }
6120 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6121 }
6122}
6123impl serde::Serialize for CreateSinkResponse {
6124 #[allow(deprecated)]
6125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6126 where
6127 S: serde::Serializer,
6128 {
6129 use serde::ser::SerializeStruct;
6130 let mut len = 0;
6131 if self.status.is_some() {
6132 len += 1;
6133 }
6134 if self.version.is_some() {
6135 len += 1;
6136 }
6137 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6138 if let Some(v) = self.status.as_ref() {
6139 struct_ser.serialize_field("status", v)?;
6140 }
6141 if let Some(v) = self.version.as_ref() {
6142 struct_ser.serialize_field("version", v)?;
6143 }
6144 struct_ser.end()
6145 }
6146}
6147impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6148 #[allow(deprecated)]
6149 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6150 where
6151 D: serde::Deserializer<'de>,
6152 {
6153 const FIELDS: &[&str] = &[
6154 "status",
6155 "version",
6156 ];
6157
6158 #[allow(clippy::enum_variant_names)]
6159 enum GeneratedField {
6160 Status,
6161 Version,
6162 }
6163 impl<'de> serde::Deserialize<'de> for GeneratedField {
6164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6165 where
6166 D: serde::Deserializer<'de>,
6167 {
6168 struct GeneratedVisitor;
6169
6170 impl serde::de::Visitor<'_> for GeneratedVisitor {
6171 type Value = GeneratedField;
6172
6173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6174 write!(formatter, "expected one of: {:?}", &FIELDS)
6175 }
6176
6177 #[allow(unused_variables)]
6178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6179 where
6180 E: serde::de::Error,
6181 {
6182 match value {
6183 "status" => Ok(GeneratedField::Status),
6184 "version" => Ok(GeneratedField::Version),
6185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6186 }
6187 }
6188 }
6189 deserializer.deserialize_identifier(GeneratedVisitor)
6190 }
6191 }
6192 struct GeneratedVisitor;
6193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6194 type Value = CreateSinkResponse;
6195
6196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6197 formatter.write_str("struct ddl_service.CreateSinkResponse")
6198 }
6199
6200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6201 where
6202 V: serde::de::MapAccess<'de>,
6203 {
6204 let mut status__ = None;
6205 let mut version__ = None;
6206 while let Some(k) = map_.next_key()? {
6207 match k {
6208 GeneratedField::Status => {
6209 if status__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("status"));
6211 }
6212 status__ = map_.next_value()?;
6213 }
6214 GeneratedField::Version => {
6215 if version__.is_some() {
6216 return Err(serde::de::Error::duplicate_field("version"));
6217 }
6218 version__ = map_.next_value()?;
6219 }
6220 }
6221 }
6222 Ok(CreateSinkResponse {
6223 status: status__,
6224 version: version__,
6225 })
6226 }
6227 }
6228 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
6229 }
6230}
6231impl serde::Serialize for CreateSourceRequest {
6232 #[allow(deprecated)]
6233 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6234 where
6235 S: serde::Serializer,
6236 {
6237 use serde::ser::SerializeStruct;
6238 let mut len = 0;
6239 if self.source.is_some() {
6240 len += 1;
6241 }
6242 if self.fragment_graph.is_some() {
6243 len += 1;
6244 }
6245 if self.if_not_exists {
6246 len += 1;
6247 }
6248 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
6249 if let Some(v) = self.source.as_ref() {
6250 struct_ser.serialize_field("source", v)?;
6251 }
6252 if let Some(v) = self.fragment_graph.as_ref() {
6253 struct_ser.serialize_field("fragmentGraph", v)?;
6254 }
6255 if self.if_not_exists {
6256 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6257 }
6258 struct_ser.end()
6259 }
6260}
6261impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
6262 #[allow(deprecated)]
6263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6264 where
6265 D: serde::Deserializer<'de>,
6266 {
6267 const FIELDS: &[&str] = &[
6268 "source",
6269 "fragment_graph",
6270 "fragmentGraph",
6271 "if_not_exists",
6272 "ifNotExists",
6273 ];
6274
6275 #[allow(clippy::enum_variant_names)]
6276 enum GeneratedField {
6277 Source,
6278 FragmentGraph,
6279 IfNotExists,
6280 }
6281 impl<'de> serde::Deserialize<'de> for GeneratedField {
6282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6283 where
6284 D: serde::Deserializer<'de>,
6285 {
6286 struct GeneratedVisitor;
6287
6288 impl serde::de::Visitor<'_> for GeneratedVisitor {
6289 type Value = GeneratedField;
6290
6291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6292 write!(formatter, "expected one of: {:?}", &FIELDS)
6293 }
6294
6295 #[allow(unused_variables)]
6296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6297 where
6298 E: serde::de::Error,
6299 {
6300 match value {
6301 "source" => Ok(GeneratedField::Source),
6302 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6303 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6305 }
6306 }
6307 }
6308 deserializer.deserialize_identifier(GeneratedVisitor)
6309 }
6310 }
6311 struct GeneratedVisitor;
6312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6313 type Value = CreateSourceRequest;
6314
6315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6316 formatter.write_str("struct ddl_service.CreateSourceRequest")
6317 }
6318
6319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
6320 where
6321 V: serde::de::MapAccess<'de>,
6322 {
6323 let mut source__ = None;
6324 let mut fragment_graph__ = None;
6325 let mut if_not_exists__ = None;
6326 while let Some(k) = map_.next_key()? {
6327 match k {
6328 GeneratedField::Source => {
6329 if source__.is_some() {
6330 return Err(serde::de::Error::duplicate_field("source"));
6331 }
6332 source__ = map_.next_value()?;
6333 }
6334 GeneratedField::FragmentGraph => {
6335 if fragment_graph__.is_some() {
6336 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6337 }
6338 fragment_graph__ = map_.next_value()?;
6339 }
6340 GeneratedField::IfNotExists => {
6341 if if_not_exists__.is_some() {
6342 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6343 }
6344 if_not_exists__ = Some(map_.next_value()?);
6345 }
6346 }
6347 }
6348 Ok(CreateSourceRequest {
6349 source: source__,
6350 fragment_graph: fragment_graph__,
6351 if_not_exists: if_not_exists__.unwrap_or_default(),
6352 })
6353 }
6354 }
6355 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
6356 }
6357}
6358impl serde::Serialize for CreateSourceResponse {
6359 #[allow(deprecated)]
6360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6361 where
6362 S: serde::Serializer,
6363 {
6364 use serde::ser::SerializeStruct;
6365 let mut len = 0;
6366 if self.status.is_some() {
6367 len += 1;
6368 }
6369 if self.version.is_some() {
6370 len += 1;
6371 }
6372 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
6373 if let Some(v) = self.status.as_ref() {
6374 struct_ser.serialize_field("status", v)?;
6375 }
6376 if let Some(v) = self.version.as_ref() {
6377 struct_ser.serialize_field("version", v)?;
6378 }
6379 struct_ser.end()
6380 }
6381}
6382impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
6383 #[allow(deprecated)]
6384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6385 where
6386 D: serde::Deserializer<'de>,
6387 {
6388 const FIELDS: &[&str] = &[
6389 "status",
6390 "version",
6391 ];
6392
6393 #[allow(clippy::enum_variant_names)]
6394 enum GeneratedField {
6395 Status,
6396 Version,
6397 }
6398 impl<'de> serde::Deserialize<'de> for GeneratedField {
6399 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6400 where
6401 D: serde::Deserializer<'de>,
6402 {
6403 struct GeneratedVisitor;
6404
6405 impl serde::de::Visitor<'_> for GeneratedVisitor {
6406 type Value = GeneratedField;
6407
6408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6409 write!(formatter, "expected one of: {:?}", &FIELDS)
6410 }
6411
6412 #[allow(unused_variables)]
6413 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6414 where
6415 E: serde::de::Error,
6416 {
6417 match value {
6418 "status" => Ok(GeneratedField::Status),
6419 "version" => Ok(GeneratedField::Version),
6420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6421 }
6422 }
6423 }
6424 deserializer.deserialize_identifier(GeneratedVisitor)
6425 }
6426 }
6427 struct GeneratedVisitor;
6428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6429 type Value = CreateSourceResponse;
6430
6431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6432 formatter.write_str("struct ddl_service.CreateSourceResponse")
6433 }
6434
6435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
6436 where
6437 V: serde::de::MapAccess<'de>,
6438 {
6439 let mut status__ = None;
6440 let mut version__ = None;
6441 while let Some(k) = map_.next_key()? {
6442 match k {
6443 GeneratedField::Status => {
6444 if status__.is_some() {
6445 return Err(serde::de::Error::duplicate_field("status"));
6446 }
6447 status__ = map_.next_value()?;
6448 }
6449 GeneratedField::Version => {
6450 if version__.is_some() {
6451 return Err(serde::de::Error::duplicate_field("version"));
6452 }
6453 version__ = map_.next_value()?;
6454 }
6455 }
6456 }
6457 Ok(CreateSourceResponse {
6458 status: status__,
6459 version: version__,
6460 })
6461 }
6462 }
6463 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
6464 }
6465}
6466impl serde::Serialize for CreateSubscriptionRequest {
6467 #[allow(deprecated)]
6468 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6469 where
6470 S: serde::Serializer,
6471 {
6472 use serde::ser::SerializeStruct;
6473 let mut len = 0;
6474 if self.subscription.is_some() {
6475 len += 1;
6476 }
6477 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
6478 if let Some(v) = self.subscription.as_ref() {
6479 struct_ser.serialize_field("subscription", v)?;
6480 }
6481 struct_ser.end()
6482 }
6483}
6484impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
6485 #[allow(deprecated)]
6486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6487 where
6488 D: serde::Deserializer<'de>,
6489 {
6490 const FIELDS: &[&str] = &[
6491 "subscription",
6492 ];
6493
6494 #[allow(clippy::enum_variant_names)]
6495 enum GeneratedField {
6496 Subscription,
6497 }
6498 impl<'de> serde::Deserialize<'de> for GeneratedField {
6499 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6500 where
6501 D: serde::Deserializer<'de>,
6502 {
6503 struct GeneratedVisitor;
6504
6505 impl serde::de::Visitor<'_> for GeneratedVisitor {
6506 type Value = GeneratedField;
6507
6508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6509 write!(formatter, "expected one of: {:?}", &FIELDS)
6510 }
6511
6512 #[allow(unused_variables)]
6513 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6514 where
6515 E: serde::de::Error,
6516 {
6517 match value {
6518 "subscription" => Ok(GeneratedField::Subscription),
6519 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6520 }
6521 }
6522 }
6523 deserializer.deserialize_identifier(GeneratedVisitor)
6524 }
6525 }
6526 struct GeneratedVisitor;
6527 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6528 type Value = CreateSubscriptionRequest;
6529
6530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6531 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
6532 }
6533
6534 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
6535 where
6536 V: serde::de::MapAccess<'de>,
6537 {
6538 let mut subscription__ = None;
6539 while let Some(k) = map_.next_key()? {
6540 match k {
6541 GeneratedField::Subscription => {
6542 if subscription__.is_some() {
6543 return Err(serde::de::Error::duplicate_field("subscription"));
6544 }
6545 subscription__ = map_.next_value()?;
6546 }
6547 }
6548 }
6549 Ok(CreateSubscriptionRequest {
6550 subscription: subscription__,
6551 })
6552 }
6553 }
6554 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
6555 }
6556}
6557impl serde::Serialize for CreateSubscriptionResponse {
6558 #[allow(deprecated)]
6559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6560 where
6561 S: serde::Serializer,
6562 {
6563 use serde::ser::SerializeStruct;
6564 let mut len = 0;
6565 if self.status.is_some() {
6566 len += 1;
6567 }
6568 if self.version.is_some() {
6569 len += 1;
6570 }
6571 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
6572 if let Some(v) = self.status.as_ref() {
6573 struct_ser.serialize_field("status", v)?;
6574 }
6575 if let Some(v) = self.version.as_ref() {
6576 struct_ser.serialize_field("version", v)?;
6577 }
6578 struct_ser.end()
6579 }
6580}
6581impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
6582 #[allow(deprecated)]
6583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6584 where
6585 D: serde::Deserializer<'de>,
6586 {
6587 const FIELDS: &[&str] = &[
6588 "status",
6589 "version",
6590 ];
6591
6592 #[allow(clippy::enum_variant_names)]
6593 enum GeneratedField {
6594 Status,
6595 Version,
6596 }
6597 impl<'de> serde::Deserialize<'de> for GeneratedField {
6598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6599 where
6600 D: serde::Deserializer<'de>,
6601 {
6602 struct GeneratedVisitor;
6603
6604 impl serde::de::Visitor<'_> for GeneratedVisitor {
6605 type Value = GeneratedField;
6606
6607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6608 write!(formatter, "expected one of: {:?}", &FIELDS)
6609 }
6610
6611 #[allow(unused_variables)]
6612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6613 where
6614 E: serde::de::Error,
6615 {
6616 match value {
6617 "status" => Ok(GeneratedField::Status),
6618 "version" => Ok(GeneratedField::Version),
6619 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6620 }
6621 }
6622 }
6623 deserializer.deserialize_identifier(GeneratedVisitor)
6624 }
6625 }
6626 struct GeneratedVisitor;
6627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6628 type Value = CreateSubscriptionResponse;
6629
6630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6631 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
6632 }
6633
6634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
6635 where
6636 V: serde::de::MapAccess<'de>,
6637 {
6638 let mut status__ = None;
6639 let mut version__ = None;
6640 while let Some(k) = map_.next_key()? {
6641 match k {
6642 GeneratedField::Status => {
6643 if status__.is_some() {
6644 return Err(serde::de::Error::duplicate_field("status"));
6645 }
6646 status__ = map_.next_value()?;
6647 }
6648 GeneratedField::Version => {
6649 if version__.is_some() {
6650 return Err(serde::de::Error::duplicate_field("version"));
6651 }
6652 version__ = map_.next_value()?;
6653 }
6654 }
6655 }
6656 Ok(CreateSubscriptionResponse {
6657 status: status__,
6658 version: version__,
6659 })
6660 }
6661 }
6662 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
6663 }
6664}
6665impl serde::Serialize for CreateTableRequest {
6666 #[allow(deprecated)]
6667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6668 where
6669 S: serde::Serializer,
6670 {
6671 use serde::ser::SerializeStruct;
6672 let mut len = 0;
6673 if self.source.is_some() {
6674 len += 1;
6675 }
6676 if self.materialized_view.is_some() {
6677 len += 1;
6678 }
6679 if self.fragment_graph.is_some() {
6680 len += 1;
6681 }
6682 if self.job_type != 0 {
6683 len += 1;
6684 }
6685 if self.if_not_exists {
6686 len += 1;
6687 }
6688 if !self.dependencies.is_empty() {
6689 len += 1;
6690 }
6691 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
6692 if let Some(v) = self.source.as_ref() {
6693 struct_ser.serialize_field("source", v)?;
6694 }
6695 if let Some(v) = self.materialized_view.as_ref() {
6696 struct_ser.serialize_field("materializedView", v)?;
6697 }
6698 if let Some(v) = self.fragment_graph.as_ref() {
6699 struct_ser.serialize_field("fragmentGraph", v)?;
6700 }
6701 if self.job_type != 0 {
6702 let v = TableJobType::try_from(self.job_type)
6703 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
6704 struct_ser.serialize_field("jobType", &v)?;
6705 }
6706 if self.if_not_exists {
6707 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6708 }
6709 if !self.dependencies.is_empty() {
6710 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6711 }
6712 struct_ser.end()
6713 }
6714}
6715impl<'de> serde::Deserialize<'de> for CreateTableRequest {
6716 #[allow(deprecated)]
6717 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6718 where
6719 D: serde::Deserializer<'de>,
6720 {
6721 const FIELDS: &[&str] = &[
6722 "source",
6723 "materialized_view",
6724 "materializedView",
6725 "fragment_graph",
6726 "fragmentGraph",
6727 "job_type",
6728 "jobType",
6729 "if_not_exists",
6730 "ifNotExists",
6731 "dependencies",
6732 ];
6733
6734 #[allow(clippy::enum_variant_names)]
6735 enum GeneratedField {
6736 Source,
6737 MaterializedView,
6738 FragmentGraph,
6739 JobType,
6740 IfNotExists,
6741 Dependencies,
6742 }
6743 impl<'de> serde::Deserialize<'de> for GeneratedField {
6744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6745 where
6746 D: serde::Deserializer<'de>,
6747 {
6748 struct GeneratedVisitor;
6749
6750 impl serde::de::Visitor<'_> for GeneratedVisitor {
6751 type Value = GeneratedField;
6752
6753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6754 write!(formatter, "expected one of: {:?}", &FIELDS)
6755 }
6756
6757 #[allow(unused_variables)]
6758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6759 where
6760 E: serde::de::Error,
6761 {
6762 match value {
6763 "source" => Ok(GeneratedField::Source),
6764 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
6765 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6766 "jobType" | "job_type" => Ok(GeneratedField::JobType),
6767 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6768 "dependencies" => Ok(GeneratedField::Dependencies),
6769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6770 }
6771 }
6772 }
6773 deserializer.deserialize_identifier(GeneratedVisitor)
6774 }
6775 }
6776 struct GeneratedVisitor;
6777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6778 type Value = CreateTableRequest;
6779
6780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6781 formatter.write_str("struct ddl_service.CreateTableRequest")
6782 }
6783
6784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
6785 where
6786 V: serde::de::MapAccess<'de>,
6787 {
6788 let mut source__ = None;
6789 let mut materialized_view__ = None;
6790 let mut fragment_graph__ = None;
6791 let mut job_type__ = None;
6792 let mut if_not_exists__ = None;
6793 let mut dependencies__ = None;
6794 while let Some(k) = map_.next_key()? {
6795 match k {
6796 GeneratedField::Source => {
6797 if source__.is_some() {
6798 return Err(serde::de::Error::duplicate_field("source"));
6799 }
6800 source__ = map_.next_value()?;
6801 }
6802 GeneratedField::MaterializedView => {
6803 if materialized_view__.is_some() {
6804 return Err(serde::de::Error::duplicate_field("materializedView"));
6805 }
6806 materialized_view__ = map_.next_value()?;
6807 }
6808 GeneratedField::FragmentGraph => {
6809 if fragment_graph__.is_some() {
6810 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6811 }
6812 fragment_graph__ = map_.next_value()?;
6813 }
6814 GeneratedField::JobType => {
6815 if job_type__.is_some() {
6816 return Err(serde::de::Error::duplicate_field("jobType"));
6817 }
6818 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
6819 }
6820 GeneratedField::IfNotExists => {
6821 if if_not_exists__.is_some() {
6822 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6823 }
6824 if_not_exists__ = Some(map_.next_value()?);
6825 }
6826 GeneratedField::Dependencies => {
6827 if dependencies__.is_some() {
6828 return Err(serde::de::Error::duplicate_field("dependencies"));
6829 }
6830 dependencies__ =
6831 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6832 .into_iter().map(|x| x.0).collect())
6833 ;
6834 }
6835 }
6836 }
6837 Ok(CreateTableRequest {
6838 source: source__,
6839 materialized_view: materialized_view__,
6840 fragment_graph: fragment_graph__,
6841 job_type: job_type__.unwrap_or_default(),
6842 if_not_exists: if_not_exists__.unwrap_or_default(),
6843 dependencies: dependencies__.unwrap_or_default(),
6844 })
6845 }
6846 }
6847 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
6848 }
6849}
6850impl serde::Serialize for CreateTableResponse {
6851 #[allow(deprecated)]
6852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6853 where
6854 S: serde::Serializer,
6855 {
6856 use serde::ser::SerializeStruct;
6857 let mut len = 0;
6858 if self.status.is_some() {
6859 len += 1;
6860 }
6861 if self.version.is_some() {
6862 len += 1;
6863 }
6864 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
6865 if let Some(v) = self.status.as_ref() {
6866 struct_ser.serialize_field("status", v)?;
6867 }
6868 if let Some(v) = self.version.as_ref() {
6869 struct_ser.serialize_field("version", v)?;
6870 }
6871 struct_ser.end()
6872 }
6873}
6874impl<'de> serde::Deserialize<'de> for CreateTableResponse {
6875 #[allow(deprecated)]
6876 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6877 where
6878 D: serde::Deserializer<'de>,
6879 {
6880 const FIELDS: &[&str] = &[
6881 "status",
6882 "version",
6883 ];
6884
6885 #[allow(clippy::enum_variant_names)]
6886 enum GeneratedField {
6887 Status,
6888 Version,
6889 }
6890 impl<'de> serde::Deserialize<'de> for GeneratedField {
6891 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6892 where
6893 D: serde::Deserializer<'de>,
6894 {
6895 struct GeneratedVisitor;
6896
6897 impl serde::de::Visitor<'_> for GeneratedVisitor {
6898 type Value = GeneratedField;
6899
6900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6901 write!(formatter, "expected one of: {:?}", &FIELDS)
6902 }
6903
6904 #[allow(unused_variables)]
6905 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6906 where
6907 E: serde::de::Error,
6908 {
6909 match value {
6910 "status" => Ok(GeneratedField::Status),
6911 "version" => Ok(GeneratedField::Version),
6912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6913 }
6914 }
6915 }
6916 deserializer.deserialize_identifier(GeneratedVisitor)
6917 }
6918 }
6919 struct GeneratedVisitor;
6920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6921 type Value = CreateTableResponse;
6922
6923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6924 formatter.write_str("struct ddl_service.CreateTableResponse")
6925 }
6926
6927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
6928 where
6929 V: serde::de::MapAccess<'de>,
6930 {
6931 let mut status__ = None;
6932 let mut version__ = None;
6933 while let Some(k) = map_.next_key()? {
6934 match k {
6935 GeneratedField::Status => {
6936 if status__.is_some() {
6937 return Err(serde::de::Error::duplicate_field("status"));
6938 }
6939 status__ = map_.next_value()?;
6940 }
6941 GeneratedField::Version => {
6942 if version__.is_some() {
6943 return Err(serde::de::Error::duplicate_field("version"));
6944 }
6945 version__ = map_.next_value()?;
6946 }
6947 }
6948 }
6949 Ok(CreateTableResponse {
6950 status: status__,
6951 version: version__,
6952 })
6953 }
6954 }
6955 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
6956 }
6957}
6958impl serde::Serialize for CreateViewRequest {
6959 #[allow(deprecated)]
6960 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6961 where
6962 S: serde::Serializer,
6963 {
6964 use serde::ser::SerializeStruct;
6965 let mut len = 0;
6966 if self.view.is_some() {
6967 len += 1;
6968 }
6969 if !self.dependencies.is_empty() {
6970 len += 1;
6971 }
6972 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
6973 if let Some(v) = self.view.as_ref() {
6974 struct_ser.serialize_field("view", v)?;
6975 }
6976 if !self.dependencies.is_empty() {
6977 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6978 }
6979 struct_ser.end()
6980 }
6981}
6982impl<'de> serde::Deserialize<'de> for CreateViewRequest {
6983 #[allow(deprecated)]
6984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6985 where
6986 D: serde::Deserializer<'de>,
6987 {
6988 const FIELDS: &[&str] = &[
6989 "view",
6990 "dependencies",
6991 ];
6992
6993 #[allow(clippy::enum_variant_names)]
6994 enum GeneratedField {
6995 View,
6996 Dependencies,
6997 }
6998 impl<'de> serde::Deserialize<'de> for GeneratedField {
6999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7000 where
7001 D: serde::Deserializer<'de>,
7002 {
7003 struct GeneratedVisitor;
7004
7005 impl serde::de::Visitor<'_> for GeneratedVisitor {
7006 type Value = GeneratedField;
7007
7008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7009 write!(formatter, "expected one of: {:?}", &FIELDS)
7010 }
7011
7012 #[allow(unused_variables)]
7013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7014 where
7015 E: serde::de::Error,
7016 {
7017 match value {
7018 "view" => Ok(GeneratedField::View),
7019 "dependencies" => Ok(GeneratedField::Dependencies),
7020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7021 }
7022 }
7023 }
7024 deserializer.deserialize_identifier(GeneratedVisitor)
7025 }
7026 }
7027 struct GeneratedVisitor;
7028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7029 type Value = CreateViewRequest;
7030
7031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7032 formatter.write_str("struct ddl_service.CreateViewRequest")
7033 }
7034
7035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7036 where
7037 V: serde::de::MapAccess<'de>,
7038 {
7039 let mut view__ = None;
7040 let mut dependencies__ = None;
7041 while let Some(k) = map_.next_key()? {
7042 match k {
7043 GeneratedField::View => {
7044 if view__.is_some() {
7045 return Err(serde::de::Error::duplicate_field("view"));
7046 }
7047 view__ = map_.next_value()?;
7048 }
7049 GeneratedField::Dependencies => {
7050 if dependencies__.is_some() {
7051 return Err(serde::de::Error::duplicate_field("dependencies"));
7052 }
7053 dependencies__ =
7054 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7055 .into_iter().map(|x| x.0).collect())
7056 ;
7057 }
7058 }
7059 }
7060 Ok(CreateViewRequest {
7061 view: view__,
7062 dependencies: dependencies__.unwrap_or_default(),
7063 })
7064 }
7065 }
7066 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7067 }
7068}
7069impl serde::Serialize for CreateViewResponse {
7070 #[allow(deprecated)]
7071 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7072 where
7073 S: serde::Serializer,
7074 {
7075 use serde::ser::SerializeStruct;
7076 let mut len = 0;
7077 if self.status.is_some() {
7078 len += 1;
7079 }
7080 if self.version.is_some() {
7081 len += 1;
7082 }
7083 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7084 if let Some(v) = self.status.as_ref() {
7085 struct_ser.serialize_field("status", v)?;
7086 }
7087 if let Some(v) = self.version.as_ref() {
7088 struct_ser.serialize_field("version", v)?;
7089 }
7090 struct_ser.end()
7091 }
7092}
7093impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7094 #[allow(deprecated)]
7095 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7096 where
7097 D: serde::Deserializer<'de>,
7098 {
7099 const FIELDS: &[&str] = &[
7100 "status",
7101 "version",
7102 ];
7103
7104 #[allow(clippy::enum_variant_names)]
7105 enum GeneratedField {
7106 Status,
7107 Version,
7108 }
7109 impl<'de> serde::Deserialize<'de> for GeneratedField {
7110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7111 where
7112 D: serde::Deserializer<'de>,
7113 {
7114 struct GeneratedVisitor;
7115
7116 impl serde::de::Visitor<'_> for GeneratedVisitor {
7117 type Value = GeneratedField;
7118
7119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7120 write!(formatter, "expected one of: {:?}", &FIELDS)
7121 }
7122
7123 #[allow(unused_variables)]
7124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7125 where
7126 E: serde::de::Error,
7127 {
7128 match value {
7129 "status" => Ok(GeneratedField::Status),
7130 "version" => Ok(GeneratedField::Version),
7131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7132 }
7133 }
7134 }
7135 deserializer.deserialize_identifier(GeneratedVisitor)
7136 }
7137 }
7138 struct GeneratedVisitor;
7139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7140 type Value = CreateViewResponse;
7141
7142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7143 formatter.write_str("struct ddl_service.CreateViewResponse")
7144 }
7145
7146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7147 where
7148 V: serde::de::MapAccess<'de>,
7149 {
7150 let mut status__ = None;
7151 let mut version__ = None;
7152 while let Some(k) = map_.next_key()? {
7153 match k {
7154 GeneratedField::Status => {
7155 if status__.is_some() {
7156 return Err(serde::de::Error::duplicate_field("status"));
7157 }
7158 status__ = map_.next_value()?;
7159 }
7160 GeneratedField::Version => {
7161 if version__.is_some() {
7162 return Err(serde::de::Error::duplicate_field("version"));
7163 }
7164 version__ = map_.next_value()?;
7165 }
7166 }
7167 }
7168 Ok(CreateViewResponse {
7169 status: status__,
7170 version: version__,
7171 })
7172 }
7173 }
7174 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7175 }
7176}
7177impl serde::Serialize for DdlProgress {
7178 #[allow(deprecated)]
7179 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7180 where
7181 S: serde::Serializer,
7182 {
7183 use serde::ser::SerializeStruct;
7184 let mut len = 0;
7185 if self.id != 0 {
7186 len += 1;
7187 }
7188 if !self.statement.is_empty() {
7189 len += 1;
7190 }
7191 if !self.progress.is_empty() {
7192 len += 1;
7193 }
7194 if !self.create_type.is_empty() {
7195 len += 1;
7196 }
7197 if self.initialized_at_time_millis != 0 {
7198 len += 1;
7199 }
7200 if self.is_serverless_backfill {
7201 len += 1;
7202 }
7203 if self.backfill_type != 0 {
7204 len += 1;
7205 }
7206 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
7207 if self.id != 0 {
7208 #[allow(clippy::needless_borrow)]
7209 #[allow(clippy::needless_borrows_for_generic_args)]
7210 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7211 }
7212 if !self.statement.is_empty() {
7213 struct_ser.serialize_field("statement", &self.statement)?;
7214 }
7215 if !self.progress.is_empty() {
7216 struct_ser.serialize_field("progress", &self.progress)?;
7217 }
7218 if !self.create_type.is_empty() {
7219 struct_ser.serialize_field("createType", &self.create_type)?;
7220 }
7221 if self.initialized_at_time_millis != 0 {
7222 #[allow(clippy::needless_borrow)]
7223 #[allow(clippy::needless_borrows_for_generic_args)]
7224 struct_ser.serialize_field("initializedAtTimeMillis", ToString::to_string(&self.initialized_at_time_millis).as_str())?;
7225 }
7226 if self.is_serverless_backfill {
7227 struct_ser.serialize_field("isServerlessBackfill", &self.is_serverless_backfill)?;
7228 }
7229 if self.backfill_type != 0 {
7230 let v = BackfillType::try_from(self.backfill_type)
7231 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill_type)))?;
7232 struct_ser.serialize_field("backfillType", &v)?;
7233 }
7234 struct_ser.end()
7235 }
7236}
7237impl<'de> serde::Deserialize<'de> for DdlProgress {
7238 #[allow(deprecated)]
7239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7240 where
7241 D: serde::Deserializer<'de>,
7242 {
7243 const FIELDS: &[&str] = &[
7244 "id",
7245 "statement",
7246 "progress",
7247 "create_type",
7248 "createType",
7249 "initialized_at_time_millis",
7250 "initializedAtTimeMillis",
7251 "is_serverless_backfill",
7252 "isServerlessBackfill",
7253 "backfill_type",
7254 "backfillType",
7255 ];
7256
7257 #[allow(clippy::enum_variant_names)]
7258 enum GeneratedField {
7259 Id,
7260 Statement,
7261 Progress,
7262 CreateType,
7263 InitializedAtTimeMillis,
7264 IsServerlessBackfill,
7265 BackfillType,
7266 }
7267 impl<'de> serde::Deserialize<'de> for GeneratedField {
7268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7269 where
7270 D: serde::Deserializer<'de>,
7271 {
7272 struct GeneratedVisitor;
7273
7274 impl serde::de::Visitor<'_> for GeneratedVisitor {
7275 type Value = GeneratedField;
7276
7277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7278 write!(formatter, "expected one of: {:?}", &FIELDS)
7279 }
7280
7281 #[allow(unused_variables)]
7282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7283 where
7284 E: serde::de::Error,
7285 {
7286 match value {
7287 "id" => Ok(GeneratedField::Id),
7288 "statement" => Ok(GeneratedField::Statement),
7289 "progress" => Ok(GeneratedField::Progress),
7290 "createType" | "create_type" => Ok(GeneratedField::CreateType),
7291 "initializedAtTimeMillis" | "initialized_at_time_millis" => Ok(GeneratedField::InitializedAtTimeMillis),
7292 "isServerlessBackfill" | "is_serverless_backfill" => Ok(GeneratedField::IsServerlessBackfill),
7293 "backfillType" | "backfill_type" => Ok(GeneratedField::BackfillType),
7294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7295 }
7296 }
7297 }
7298 deserializer.deserialize_identifier(GeneratedVisitor)
7299 }
7300 }
7301 struct GeneratedVisitor;
7302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7303 type Value = DdlProgress;
7304
7305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7306 formatter.write_str("struct ddl_service.DdlProgress")
7307 }
7308
7309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
7310 where
7311 V: serde::de::MapAccess<'de>,
7312 {
7313 let mut id__ = None;
7314 let mut statement__ = None;
7315 let mut progress__ = None;
7316 let mut create_type__ = None;
7317 let mut initialized_at_time_millis__ = None;
7318 let mut is_serverless_backfill__ = None;
7319 let mut backfill_type__ = None;
7320 while let Some(k) = map_.next_key()? {
7321 match k {
7322 GeneratedField::Id => {
7323 if id__.is_some() {
7324 return Err(serde::de::Error::duplicate_field("id"));
7325 }
7326 id__ =
7327 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7328 ;
7329 }
7330 GeneratedField::Statement => {
7331 if statement__.is_some() {
7332 return Err(serde::de::Error::duplicate_field("statement"));
7333 }
7334 statement__ = Some(map_.next_value()?);
7335 }
7336 GeneratedField::Progress => {
7337 if progress__.is_some() {
7338 return Err(serde::de::Error::duplicate_field("progress"));
7339 }
7340 progress__ = Some(map_.next_value()?);
7341 }
7342 GeneratedField::CreateType => {
7343 if create_type__.is_some() {
7344 return Err(serde::de::Error::duplicate_field("createType"));
7345 }
7346 create_type__ = Some(map_.next_value()?);
7347 }
7348 GeneratedField::InitializedAtTimeMillis => {
7349 if initialized_at_time_millis__.is_some() {
7350 return Err(serde::de::Error::duplicate_field("initializedAtTimeMillis"));
7351 }
7352 initialized_at_time_millis__ =
7353 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7354 ;
7355 }
7356 GeneratedField::IsServerlessBackfill => {
7357 if is_serverless_backfill__.is_some() {
7358 return Err(serde::de::Error::duplicate_field("isServerlessBackfill"));
7359 }
7360 is_serverless_backfill__ = Some(map_.next_value()?);
7361 }
7362 GeneratedField::BackfillType => {
7363 if backfill_type__.is_some() {
7364 return Err(serde::de::Error::duplicate_field("backfillType"));
7365 }
7366 backfill_type__ = Some(map_.next_value::<BackfillType>()? as i32);
7367 }
7368 }
7369 }
7370 Ok(DdlProgress {
7371 id: id__.unwrap_or_default(),
7372 statement: statement__.unwrap_or_default(),
7373 progress: progress__.unwrap_or_default(),
7374 create_type: create_type__.unwrap_or_default(),
7375 initialized_at_time_millis: initialized_at_time_millis__.unwrap_or_default(),
7376 is_serverless_backfill: is_serverless_backfill__.unwrap_or_default(),
7377 backfill_type: backfill_type__.unwrap_or_default(),
7378 })
7379 }
7380 }
7381 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
7382 }
7383}
7384impl serde::Serialize for DropConnectionRequest {
7385 #[allow(deprecated)]
7386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7387 where
7388 S: serde::Serializer,
7389 {
7390 use serde::ser::SerializeStruct;
7391 let mut len = 0;
7392 if self.connection_id != 0 {
7393 len += 1;
7394 }
7395 if self.cascade {
7396 len += 1;
7397 }
7398 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
7399 if self.connection_id != 0 {
7400 struct_ser.serialize_field("connectionId", &self.connection_id)?;
7401 }
7402 if self.cascade {
7403 struct_ser.serialize_field("cascade", &self.cascade)?;
7404 }
7405 struct_ser.end()
7406 }
7407}
7408impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
7409 #[allow(deprecated)]
7410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7411 where
7412 D: serde::Deserializer<'de>,
7413 {
7414 const FIELDS: &[&str] = &[
7415 "connection_id",
7416 "connectionId",
7417 "cascade",
7418 ];
7419
7420 #[allow(clippy::enum_variant_names)]
7421 enum GeneratedField {
7422 ConnectionId,
7423 Cascade,
7424 }
7425 impl<'de> serde::Deserialize<'de> for GeneratedField {
7426 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7427 where
7428 D: serde::Deserializer<'de>,
7429 {
7430 struct GeneratedVisitor;
7431
7432 impl serde::de::Visitor<'_> for GeneratedVisitor {
7433 type Value = GeneratedField;
7434
7435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7436 write!(formatter, "expected one of: {:?}", &FIELDS)
7437 }
7438
7439 #[allow(unused_variables)]
7440 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7441 where
7442 E: serde::de::Error,
7443 {
7444 match value {
7445 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
7446 "cascade" => Ok(GeneratedField::Cascade),
7447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7448 }
7449 }
7450 }
7451 deserializer.deserialize_identifier(GeneratedVisitor)
7452 }
7453 }
7454 struct GeneratedVisitor;
7455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7456 type Value = DropConnectionRequest;
7457
7458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7459 formatter.write_str("struct ddl_service.DropConnectionRequest")
7460 }
7461
7462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
7463 where
7464 V: serde::de::MapAccess<'de>,
7465 {
7466 let mut connection_id__ = None;
7467 let mut cascade__ = None;
7468 while let Some(k) = map_.next_key()? {
7469 match k {
7470 GeneratedField::ConnectionId => {
7471 if connection_id__.is_some() {
7472 return Err(serde::de::Error::duplicate_field("connectionId"));
7473 }
7474 connection_id__ =
7475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7476 ;
7477 }
7478 GeneratedField::Cascade => {
7479 if cascade__.is_some() {
7480 return Err(serde::de::Error::duplicate_field("cascade"));
7481 }
7482 cascade__ = Some(map_.next_value()?);
7483 }
7484 }
7485 }
7486 Ok(DropConnectionRequest {
7487 connection_id: connection_id__.unwrap_or_default(),
7488 cascade: cascade__.unwrap_or_default(),
7489 })
7490 }
7491 }
7492 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
7493 }
7494}
7495impl serde::Serialize for DropConnectionResponse {
7496 #[allow(deprecated)]
7497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7498 where
7499 S: serde::Serializer,
7500 {
7501 use serde::ser::SerializeStruct;
7502 let mut len = 0;
7503 if self.status.is_some() {
7504 len += 1;
7505 }
7506 if self.version.is_some() {
7507 len += 1;
7508 }
7509 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
7510 if let Some(v) = self.status.as_ref() {
7511 struct_ser.serialize_field("status", v)?;
7512 }
7513 if let Some(v) = self.version.as_ref() {
7514 struct_ser.serialize_field("version", v)?;
7515 }
7516 struct_ser.end()
7517 }
7518}
7519impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
7520 #[allow(deprecated)]
7521 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7522 where
7523 D: serde::Deserializer<'de>,
7524 {
7525 const FIELDS: &[&str] = &[
7526 "status",
7527 "version",
7528 ];
7529
7530 #[allow(clippy::enum_variant_names)]
7531 enum GeneratedField {
7532 Status,
7533 Version,
7534 }
7535 impl<'de> serde::Deserialize<'de> for GeneratedField {
7536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7537 where
7538 D: serde::Deserializer<'de>,
7539 {
7540 struct GeneratedVisitor;
7541
7542 impl serde::de::Visitor<'_> for GeneratedVisitor {
7543 type Value = GeneratedField;
7544
7545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7546 write!(formatter, "expected one of: {:?}", &FIELDS)
7547 }
7548
7549 #[allow(unused_variables)]
7550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7551 where
7552 E: serde::de::Error,
7553 {
7554 match value {
7555 "status" => Ok(GeneratedField::Status),
7556 "version" => Ok(GeneratedField::Version),
7557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7558 }
7559 }
7560 }
7561 deserializer.deserialize_identifier(GeneratedVisitor)
7562 }
7563 }
7564 struct GeneratedVisitor;
7565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7566 type Value = DropConnectionResponse;
7567
7568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7569 formatter.write_str("struct ddl_service.DropConnectionResponse")
7570 }
7571
7572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
7573 where
7574 V: serde::de::MapAccess<'de>,
7575 {
7576 let mut status__ = None;
7577 let mut version__ = None;
7578 while let Some(k) = map_.next_key()? {
7579 match k {
7580 GeneratedField::Status => {
7581 if status__.is_some() {
7582 return Err(serde::de::Error::duplicate_field("status"));
7583 }
7584 status__ = map_.next_value()?;
7585 }
7586 GeneratedField::Version => {
7587 if version__.is_some() {
7588 return Err(serde::de::Error::duplicate_field("version"));
7589 }
7590 version__ = map_.next_value()?;
7591 }
7592 }
7593 }
7594 Ok(DropConnectionResponse {
7595 status: status__,
7596 version: version__,
7597 })
7598 }
7599 }
7600 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
7601 }
7602}
7603impl serde::Serialize for DropDatabaseRequest {
7604 #[allow(deprecated)]
7605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7606 where
7607 S: serde::Serializer,
7608 {
7609 use serde::ser::SerializeStruct;
7610 let mut len = 0;
7611 if self.database_id != 0 {
7612 len += 1;
7613 }
7614 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
7615 if self.database_id != 0 {
7616 struct_ser.serialize_field("databaseId", &self.database_id)?;
7617 }
7618 struct_ser.end()
7619 }
7620}
7621impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
7622 #[allow(deprecated)]
7623 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7624 where
7625 D: serde::Deserializer<'de>,
7626 {
7627 const FIELDS: &[&str] = &[
7628 "database_id",
7629 "databaseId",
7630 ];
7631
7632 #[allow(clippy::enum_variant_names)]
7633 enum GeneratedField {
7634 DatabaseId,
7635 }
7636 impl<'de> serde::Deserialize<'de> for GeneratedField {
7637 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7638 where
7639 D: serde::Deserializer<'de>,
7640 {
7641 struct GeneratedVisitor;
7642
7643 impl serde::de::Visitor<'_> for GeneratedVisitor {
7644 type Value = GeneratedField;
7645
7646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7647 write!(formatter, "expected one of: {:?}", &FIELDS)
7648 }
7649
7650 #[allow(unused_variables)]
7651 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7652 where
7653 E: serde::de::Error,
7654 {
7655 match value {
7656 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7658 }
7659 }
7660 }
7661 deserializer.deserialize_identifier(GeneratedVisitor)
7662 }
7663 }
7664 struct GeneratedVisitor;
7665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7666 type Value = DropDatabaseRequest;
7667
7668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7669 formatter.write_str("struct ddl_service.DropDatabaseRequest")
7670 }
7671
7672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
7673 where
7674 V: serde::de::MapAccess<'de>,
7675 {
7676 let mut database_id__ = None;
7677 while let Some(k) = map_.next_key()? {
7678 match k {
7679 GeneratedField::DatabaseId => {
7680 if database_id__.is_some() {
7681 return Err(serde::de::Error::duplicate_field("databaseId"));
7682 }
7683 database_id__ =
7684 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7685 ;
7686 }
7687 }
7688 }
7689 Ok(DropDatabaseRequest {
7690 database_id: database_id__.unwrap_or_default(),
7691 })
7692 }
7693 }
7694 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
7695 }
7696}
7697impl serde::Serialize for DropDatabaseResponse {
7698 #[allow(deprecated)]
7699 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7700 where
7701 S: serde::Serializer,
7702 {
7703 use serde::ser::SerializeStruct;
7704 let mut len = 0;
7705 if self.status.is_some() {
7706 len += 1;
7707 }
7708 if self.version.is_some() {
7709 len += 1;
7710 }
7711 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
7712 if let Some(v) = self.status.as_ref() {
7713 struct_ser.serialize_field("status", v)?;
7714 }
7715 if let Some(v) = self.version.as_ref() {
7716 struct_ser.serialize_field("version", v)?;
7717 }
7718 struct_ser.end()
7719 }
7720}
7721impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
7722 #[allow(deprecated)]
7723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7724 where
7725 D: serde::Deserializer<'de>,
7726 {
7727 const FIELDS: &[&str] = &[
7728 "status",
7729 "version",
7730 ];
7731
7732 #[allow(clippy::enum_variant_names)]
7733 enum GeneratedField {
7734 Status,
7735 Version,
7736 }
7737 impl<'de> serde::Deserialize<'de> for GeneratedField {
7738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7739 where
7740 D: serde::Deserializer<'de>,
7741 {
7742 struct GeneratedVisitor;
7743
7744 impl serde::de::Visitor<'_> for GeneratedVisitor {
7745 type Value = GeneratedField;
7746
7747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7748 write!(formatter, "expected one of: {:?}", &FIELDS)
7749 }
7750
7751 #[allow(unused_variables)]
7752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7753 where
7754 E: serde::de::Error,
7755 {
7756 match value {
7757 "status" => Ok(GeneratedField::Status),
7758 "version" => Ok(GeneratedField::Version),
7759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7760 }
7761 }
7762 }
7763 deserializer.deserialize_identifier(GeneratedVisitor)
7764 }
7765 }
7766 struct GeneratedVisitor;
7767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7768 type Value = DropDatabaseResponse;
7769
7770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7771 formatter.write_str("struct ddl_service.DropDatabaseResponse")
7772 }
7773
7774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
7775 where
7776 V: serde::de::MapAccess<'de>,
7777 {
7778 let mut status__ = None;
7779 let mut version__ = None;
7780 while let Some(k) = map_.next_key()? {
7781 match k {
7782 GeneratedField::Status => {
7783 if status__.is_some() {
7784 return Err(serde::de::Error::duplicate_field("status"));
7785 }
7786 status__ = map_.next_value()?;
7787 }
7788 GeneratedField::Version => {
7789 if version__.is_some() {
7790 return Err(serde::de::Error::duplicate_field("version"));
7791 }
7792 version__ = map_.next_value()?;
7793 }
7794 }
7795 }
7796 Ok(DropDatabaseResponse {
7797 status: status__,
7798 version: version__,
7799 })
7800 }
7801 }
7802 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
7803 }
7804}
7805impl serde::Serialize for DropFunctionRequest {
7806 #[allow(deprecated)]
7807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7808 where
7809 S: serde::Serializer,
7810 {
7811 use serde::ser::SerializeStruct;
7812 let mut len = 0;
7813 if self.function_id != 0 {
7814 len += 1;
7815 }
7816 if self.cascade {
7817 len += 1;
7818 }
7819 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
7820 if self.function_id != 0 {
7821 struct_ser.serialize_field("functionId", &self.function_id)?;
7822 }
7823 if self.cascade {
7824 struct_ser.serialize_field("cascade", &self.cascade)?;
7825 }
7826 struct_ser.end()
7827 }
7828}
7829impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
7830 #[allow(deprecated)]
7831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7832 where
7833 D: serde::Deserializer<'de>,
7834 {
7835 const FIELDS: &[&str] = &[
7836 "function_id",
7837 "functionId",
7838 "cascade",
7839 ];
7840
7841 #[allow(clippy::enum_variant_names)]
7842 enum GeneratedField {
7843 FunctionId,
7844 Cascade,
7845 }
7846 impl<'de> serde::Deserialize<'de> for GeneratedField {
7847 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7848 where
7849 D: serde::Deserializer<'de>,
7850 {
7851 struct GeneratedVisitor;
7852
7853 impl serde::de::Visitor<'_> for GeneratedVisitor {
7854 type Value = GeneratedField;
7855
7856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7857 write!(formatter, "expected one of: {:?}", &FIELDS)
7858 }
7859
7860 #[allow(unused_variables)]
7861 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7862 where
7863 E: serde::de::Error,
7864 {
7865 match value {
7866 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
7867 "cascade" => Ok(GeneratedField::Cascade),
7868 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7869 }
7870 }
7871 }
7872 deserializer.deserialize_identifier(GeneratedVisitor)
7873 }
7874 }
7875 struct GeneratedVisitor;
7876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7877 type Value = DropFunctionRequest;
7878
7879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7880 formatter.write_str("struct ddl_service.DropFunctionRequest")
7881 }
7882
7883 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
7884 where
7885 V: serde::de::MapAccess<'de>,
7886 {
7887 let mut function_id__ = None;
7888 let mut cascade__ = None;
7889 while let Some(k) = map_.next_key()? {
7890 match k {
7891 GeneratedField::FunctionId => {
7892 if function_id__.is_some() {
7893 return Err(serde::de::Error::duplicate_field("functionId"));
7894 }
7895 function_id__ =
7896 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7897 ;
7898 }
7899 GeneratedField::Cascade => {
7900 if cascade__.is_some() {
7901 return Err(serde::de::Error::duplicate_field("cascade"));
7902 }
7903 cascade__ = Some(map_.next_value()?);
7904 }
7905 }
7906 }
7907 Ok(DropFunctionRequest {
7908 function_id: function_id__.unwrap_or_default(),
7909 cascade: cascade__.unwrap_or_default(),
7910 })
7911 }
7912 }
7913 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
7914 }
7915}
7916impl serde::Serialize for DropFunctionResponse {
7917 #[allow(deprecated)]
7918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7919 where
7920 S: serde::Serializer,
7921 {
7922 use serde::ser::SerializeStruct;
7923 let mut len = 0;
7924 if self.status.is_some() {
7925 len += 1;
7926 }
7927 if self.version.is_some() {
7928 len += 1;
7929 }
7930 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
7931 if let Some(v) = self.status.as_ref() {
7932 struct_ser.serialize_field("status", v)?;
7933 }
7934 if let Some(v) = self.version.as_ref() {
7935 struct_ser.serialize_field("version", v)?;
7936 }
7937 struct_ser.end()
7938 }
7939}
7940impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
7941 #[allow(deprecated)]
7942 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7943 where
7944 D: serde::Deserializer<'de>,
7945 {
7946 const FIELDS: &[&str] = &[
7947 "status",
7948 "version",
7949 ];
7950
7951 #[allow(clippy::enum_variant_names)]
7952 enum GeneratedField {
7953 Status,
7954 Version,
7955 }
7956 impl<'de> serde::Deserialize<'de> for GeneratedField {
7957 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7958 where
7959 D: serde::Deserializer<'de>,
7960 {
7961 struct GeneratedVisitor;
7962
7963 impl serde::de::Visitor<'_> for GeneratedVisitor {
7964 type Value = GeneratedField;
7965
7966 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7967 write!(formatter, "expected one of: {:?}", &FIELDS)
7968 }
7969
7970 #[allow(unused_variables)]
7971 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7972 where
7973 E: serde::de::Error,
7974 {
7975 match value {
7976 "status" => Ok(GeneratedField::Status),
7977 "version" => Ok(GeneratedField::Version),
7978 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7979 }
7980 }
7981 }
7982 deserializer.deserialize_identifier(GeneratedVisitor)
7983 }
7984 }
7985 struct GeneratedVisitor;
7986 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7987 type Value = DropFunctionResponse;
7988
7989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7990 formatter.write_str("struct ddl_service.DropFunctionResponse")
7991 }
7992
7993 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
7994 where
7995 V: serde::de::MapAccess<'de>,
7996 {
7997 let mut status__ = None;
7998 let mut version__ = None;
7999 while let Some(k) = map_.next_key()? {
8000 match k {
8001 GeneratedField::Status => {
8002 if status__.is_some() {
8003 return Err(serde::de::Error::duplicate_field("status"));
8004 }
8005 status__ = map_.next_value()?;
8006 }
8007 GeneratedField::Version => {
8008 if version__.is_some() {
8009 return Err(serde::de::Error::duplicate_field("version"));
8010 }
8011 version__ = map_.next_value()?;
8012 }
8013 }
8014 }
8015 Ok(DropFunctionResponse {
8016 status: status__,
8017 version: version__,
8018 })
8019 }
8020 }
8021 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
8022 }
8023}
8024impl serde::Serialize for DropIndexRequest {
8025 #[allow(deprecated)]
8026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8027 where
8028 S: serde::Serializer,
8029 {
8030 use serde::ser::SerializeStruct;
8031 let mut len = 0;
8032 if self.index_id != 0 {
8033 len += 1;
8034 }
8035 if self.cascade {
8036 len += 1;
8037 }
8038 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
8039 if self.index_id != 0 {
8040 struct_ser.serialize_field("indexId", &self.index_id)?;
8041 }
8042 if self.cascade {
8043 struct_ser.serialize_field("cascade", &self.cascade)?;
8044 }
8045 struct_ser.end()
8046 }
8047}
8048impl<'de> serde::Deserialize<'de> for DropIndexRequest {
8049 #[allow(deprecated)]
8050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8051 where
8052 D: serde::Deserializer<'de>,
8053 {
8054 const FIELDS: &[&str] = &[
8055 "index_id",
8056 "indexId",
8057 "cascade",
8058 ];
8059
8060 #[allow(clippy::enum_variant_names)]
8061 enum GeneratedField {
8062 IndexId,
8063 Cascade,
8064 }
8065 impl<'de> serde::Deserialize<'de> for GeneratedField {
8066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8067 where
8068 D: serde::Deserializer<'de>,
8069 {
8070 struct GeneratedVisitor;
8071
8072 impl serde::de::Visitor<'_> for GeneratedVisitor {
8073 type Value = GeneratedField;
8074
8075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8076 write!(formatter, "expected one of: {:?}", &FIELDS)
8077 }
8078
8079 #[allow(unused_variables)]
8080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8081 where
8082 E: serde::de::Error,
8083 {
8084 match value {
8085 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8086 "cascade" => Ok(GeneratedField::Cascade),
8087 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8088 }
8089 }
8090 }
8091 deserializer.deserialize_identifier(GeneratedVisitor)
8092 }
8093 }
8094 struct GeneratedVisitor;
8095 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8096 type Value = DropIndexRequest;
8097
8098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8099 formatter.write_str("struct ddl_service.DropIndexRequest")
8100 }
8101
8102 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8103 where
8104 V: serde::de::MapAccess<'de>,
8105 {
8106 let mut index_id__ = None;
8107 let mut cascade__ = None;
8108 while let Some(k) = map_.next_key()? {
8109 match k {
8110 GeneratedField::IndexId => {
8111 if index_id__.is_some() {
8112 return Err(serde::de::Error::duplicate_field("indexId"));
8113 }
8114 index_id__ =
8115 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8116 ;
8117 }
8118 GeneratedField::Cascade => {
8119 if cascade__.is_some() {
8120 return Err(serde::de::Error::duplicate_field("cascade"));
8121 }
8122 cascade__ = Some(map_.next_value()?);
8123 }
8124 }
8125 }
8126 Ok(DropIndexRequest {
8127 index_id: index_id__.unwrap_or_default(),
8128 cascade: cascade__.unwrap_or_default(),
8129 })
8130 }
8131 }
8132 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8133 }
8134}
8135impl serde::Serialize for DropIndexResponse {
8136 #[allow(deprecated)]
8137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8138 where
8139 S: serde::Serializer,
8140 {
8141 use serde::ser::SerializeStruct;
8142 let mut len = 0;
8143 if self.status.is_some() {
8144 len += 1;
8145 }
8146 if self.version.is_some() {
8147 len += 1;
8148 }
8149 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8150 if let Some(v) = self.status.as_ref() {
8151 struct_ser.serialize_field("status", v)?;
8152 }
8153 if let Some(v) = self.version.as_ref() {
8154 struct_ser.serialize_field("version", v)?;
8155 }
8156 struct_ser.end()
8157 }
8158}
8159impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8160 #[allow(deprecated)]
8161 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8162 where
8163 D: serde::Deserializer<'de>,
8164 {
8165 const FIELDS: &[&str] = &[
8166 "status",
8167 "version",
8168 ];
8169
8170 #[allow(clippy::enum_variant_names)]
8171 enum GeneratedField {
8172 Status,
8173 Version,
8174 }
8175 impl<'de> serde::Deserialize<'de> for GeneratedField {
8176 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8177 where
8178 D: serde::Deserializer<'de>,
8179 {
8180 struct GeneratedVisitor;
8181
8182 impl serde::de::Visitor<'_> for GeneratedVisitor {
8183 type Value = GeneratedField;
8184
8185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8186 write!(formatter, "expected one of: {:?}", &FIELDS)
8187 }
8188
8189 #[allow(unused_variables)]
8190 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8191 where
8192 E: serde::de::Error,
8193 {
8194 match value {
8195 "status" => Ok(GeneratedField::Status),
8196 "version" => Ok(GeneratedField::Version),
8197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8198 }
8199 }
8200 }
8201 deserializer.deserialize_identifier(GeneratedVisitor)
8202 }
8203 }
8204 struct GeneratedVisitor;
8205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8206 type Value = DropIndexResponse;
8207
8208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8209 formatter.write_str("struct ddl_service.DropIndexResponse")
8210 }
8211
8212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
8213 where
8214 V: serde::de::MapAccess<'de>,
8215 {
8216 let mut status__ = None;
8217 let mut version__ = None;
8218 while let Some(k) = map_.next_key()? {
8219 match k {
8220 GeneratedField::Status => {
8221 if status__.is_some() {
8222 return Err(serde::de::Error::duplicate_field("status"));
8223 }
8224 status__ = map_.next_value()?;
8225 }
8226 GeneratedField::Version => {
8227 if version__.is_some() {
8228 return Err(serde::de::Error::duplicate_field("version"));
8229 }
8230 version__ = map_.next_value()?;
8231 }
8232 }
8233 }
8234 Ok(DropIndexResponse {
8235 status: status__,
8236 version: version__,
8237 })
8238 }
8239 }
8240 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
8241 }
8242}
8243impl serde::Serialize for DropMaterializedViewRequest {
8244 #[allow(deprecated)]
8245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8246 where
8247 S: serde::Serializer,
8248 {
8249 use serde::ser::SerializeStruct;
8250 let mut len = 0;
8251 if self.table_id != 0 {
8252 len += 1;
8253 }
8254 if self.cascade {
8255 len += 1;
8256 }
8257 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
8258 if self.table_id != 0 {
8259 struct_ser.serialize_field("tableId", &self.table_id)?;
8260 }
8261 if self.cascade {
8262 struct_ser.serialize_field("cascade", &self.cascade)?;
8263 }
8264 struct_ser.end()
8265 }
8266}
8267impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
8268 #[allow(deprecated)]
8269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8270 where
8271 D: serde::Deserializer<'de>,
8272 {
8273 const FIELDS: &[&str] = &[
8274 "table_id",
8275 "tableId",
8276 "cascade",
8277 ];
8278
8279 #[allow(clippy::enum_variant_names)]
8280 enum GeneratedField {
8281 TableId,
8282 Cascade,
8283 }
8284 impl<'de> serde::Deserialize<'de> for GeneratedField {
8285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8286 where
8287 D: serde::Deserializer<'de>,
8288 {
8289 struct GeneratedVisitor;
8290
8291 impl serde::de::Visitor<'_> for GeneratedVisitor {
8292 type Value = GeneratedField;
8293
8294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8295 write!(formatter, "expected one of: {:?}", &FIELDS)
8296 }
8297
8298 #[allow(unused_variables)]
8299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8300 where
8301 E: serde::de::Error,
8302 {
8303 match value {
8304 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8305 "cascade" => Ok(GeneratedField::Cascade),
8306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8307 }
8308 }
8309 }
8310 deserializer.deserialize_identifier(GeneratedVisitor)
8311 }
8312 }
8313 struct GeneratedVisitor;
8314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8315 type Value = DropMaterializedViewRequest;
8316
8317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8318 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
8319 }
8320
8321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
8322 where
8323 V: serde::de::MapAccess<'de>,
8324 {
8325 let mut table_id__ = None;
8326 let mut cascade__ = None;
8327 while let Some(k) = map_.next_key()? {
8328 match k {
8329 GeneratedField::TableId => {
8330 if table_id__.is_some() {
8331 return Err(serde::de::Error::duplicate_field("tableId"));
8332 }
8333 table_id__ =
8334 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8335 ;
8336 }
8337 GeneratedField::Cascade => {
8338 if cascade__.is_some() {
8339 return Err(serde::de::Error::duplicate_field("cascade"));
8340 }
8341 cascade__ = Some(map_.next_value()?);
8342 }
8343 }
8344 }
8345 Ok(DropMaterializedViewRequest {
8346 table_id: table_id__.unwrap_or_default(),
8347 cascade: cascade__.unwrap_or_default(),
8348 })
8349 }
8350 }
8351 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
8352 }
8353}
8354impl serde::Serialize for DropMaterializedViewResponse {
8355 #[allow(deprecated)]
8356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8357 where
8358 S: serde::Serializer,
8359 {
8360 use serde::ser::SerializeStruct;
8361 let mut len = 0;
8362 if self.status.is_some() {
8363 len += 1;
8364 }
8365 if self.version.is_some() {
8366 len += 1;
8367 }
8368 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
8369 if let Some(v) = self.status.as_ref() {
8370 struct_ser.serialize_field("status", v)?;
8371 }
8372 if let Some(v) = self.version.as_ref() {
8373 struct_ser.serialize_field("version", v)?;
8374 }
8375 struct_ser.end()
8376 }
8377}
8378impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
8379 #[allow(deprecated)]
8380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8381 where
8382 D: serde::Deserializer<'de>,
8383 {
8384 const FIELDS: &[&str] = &[
8385 "status",
8386 "version",
8387 ];
8388
8389 #[allow(clippy::enum_variant_names)]
8390 enum GeneratedField {
8391 Status,
8392 Version,
8393 }
8394 impl<'de> serde::Deserialize<'de> for GeneratedField {
8395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8396 where
8397 D: serde::Deserializer<'de>,
8398 {
8399 struct GeneratedVisitor;
8400
8401 impl serde::de::Visitor<'_> for GeneratedVisitor {
8402 type Value = GeneratedField;
8403
8404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8405 write!(formatter, "expected one of: {:?}", &FIELDS)
8406 }
8407
8408 #[allow(unused_variables)]
8409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8410 where
8411 E: serde::de::Error,
8412 {
8413 match value {
8414 "status" => Ok(GeneratedField::Status),
8415 "version" => Ok(GeneratedField::Version),
8416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8417 }
8418 }
8419 }
8420 deserializer.deserialize_identifier(GeneratedVisitor)
8421 }
8422 }
8423 struct GeneratedVisitor;
8424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8425 type Value = DropMaterializedViewResponse;
8426
8427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8428 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
8429 }
8430
8431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
8432 where
8433 V: serde::de::MapAccess<'de>,
8434 {
8435 let mut status__ = None;
8436 let mut version__ = None;
8437 while let Some(k) = map_.next_key()? {
8438 match k {
8439 GeneratedField::Status => {
8440 if status__.is_some() {
8441 return Err(serde::de::Error::duplicate_field("status"));
8442 }
8443 status__ = map_.next_value()?;
8444 }
8445 GeneratedField::Version => {
8446 if version__.is_some() {
8447 return Err(serde::de::Error::duplicate_field("version"));
8448 }
8449 version__ = map_.next_value()?;
8450 }
8451 }
8452 }
8453 Ok(DropMaterializedViewResponse {
8454 status: status__,
8455 version: version__,
8456 })
8457 }
8458 }
8459 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
8460 }
8461}
8462impl serde::Serialize for DropSchemaRequest {
8463 #[allow(deprecated)]
8464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8465 where
8466 S: serde::Serializer,
8467 {
8468 use serde::ser::SerializeStruct;
8469 let mut len = 0;
8470 if self.schema_id != 0 {
8471 len += 1;
8472 }
8473 if self.cascade {
8474 len += 1;
8475 }
8476 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
8477 if self.schema_id != 0 {
8478 struct_ser.serialize_field("schemaId", &self.schema_id)?;
8479 }
8480 if self.cascade {
8481 struct_ser.serialize_field("cascade", &self.cascade)?;
8482 }
8483 struct_ser.end()
8484 }
8485}
8486impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
8487 #[allow(deprecated)]
8488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8489 where
8490 D: serde::Deserializer<'de>,
8491 {
8492 const FIELDS: &[&str] = &[
8493 "schema_id",
8494 "schemaId",
8495 "cascade",
8496 ];
8497
8498 #[allow(clippy::enum_variant_names)]
8499 enum GeneratedField {
8500 SchemaId,
8501 Cascade,
8502 }
8503 impl<'de> serde::Deserialize<'de> for GeneratedField {
8504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8505 where
8506 D: serde::Deserializer<'de>,
8507 {
8508 struct GeneratedVisitor;
8509
8510 impl serde::de::Visitor<'_> for GeneratedVisitor {
8511 type Value = GeneratedField;
8512
8513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8514 write!(formatter, "expected one of: {:?}", &FIELDS)
8515 }
8516
8517 #[allow(unused_variables)]
8518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8519 where
8520 E: serde::de::Error,
8521 {
8522 match value {
8523 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
8524 "cascade" => Ok(GeneratedField::Cascade),
8525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8526 }
8527 }
8528 }
8529 deserializer.deserialize_identifier(GeneratedVisitor)
8530 }
8531 }
8532 struct GeneratedVisitor;
8533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8534 type Value = DropSchemaRequest;
8535
8536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8537 formatter.write_str("struct ddl_service.DropSchemaRequest")
8538 }
8539
8540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
8541 where
8542 V: serde::de::MapAccess<'de>,
8543 {
8544 let mut schema_id__ = None;
8545 let mut cascade__ = None;
8546 while let Some(k) = map_.next_key()? {
8547 match k {
8548 GeneratedField::SchemaId => {
8549 if schema_id__.is_some() {
8550 return Err(serde::de::Error::duplicate_field("schemaId"));
8551 }
8552 schema_id__ =
8553 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8554 ;
8555 }
8556 GeneratedField::Cascade => {
8557 if cascade__.is_some() {
8558 return Err(serde::de::Error::duplicate_field("cascade"));
8559 }
8560 cascade__ = Some(map_.next_value()?);
8561 }
8562 }
8563 }
8564 Ok(DropSchemaRequest {
8565 schema_id: schema_id__.unwrap_or_default(),
8566 cascade: cascade__.unwrap_or_default(),
8567 })
8568 }
8569 }
8570 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
8571 }
8572}
8573impl serde::Serialize for DropSchemaResponse {
8574 #[allow(deprecated)]
8575 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8576 where
8577 S: serde::Serializer,
8578 {
8579 use serde::ser::SerializeStruct;
8580 let mut len = 0;
8581 if self.status.is_some() {
8582 len += 1;
8583 }
8584 if self.version.is_some() {
8585 len += 1;
8586 }
8587 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
8588 if let Some(v) = self.status.as_ref() {
8589 struct_ser.serialize_field("status", v)?;
8590 }
8591 if let Some(v) = self.version.as_ref() {
8592 struct_ser.serialize_field("version", v)?;
8593 }
8594 struct_ser.end()
8595 }
8596}
8597impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
8598 #[allow(deprecated)]
8599 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8600 where
8601 D: serde::Deserializer<'de>,
8602 {
8603 const FIELDS: &[&str] = &[
8604 "status",
8605 "version",
8606 ];
8607
8608 #[allow(clippy::enum_variant_names)]
8609 enum GeneratedField {
8610 Status,
8611 Version,
8612 }
8613 impl<'de> serde::Deserialize<'de> for GeneratedField {
8614 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8615 where
8616 D: serde::Deserializer<'de>,
8617 {
8618 struct GeneratedVisitor;
8619
8620 impl serde::de::Visitor<'_> for GeneratedVisitor {
8621 type Value = GeneratedField;
8622
8623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8624 write!(formatter, "expected one of: {:?}", &FIELDS)
8625 }
8626
8627 #[allow(unused_variables)]
8628 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8629 where
8630 E: serde::de::Error,
8631 {
8632 match value {
8633 "status" => Ok(GeneratedField::Status),
8634 "version" => Ok(GeneratedField::Version),
8635 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8636 }
8637 }
8638 }
8639 deserializer.deserialize_identifier(GeneratedVisitor)
8640 }
8641 }
8642 struct GeneratedVisitor;
8643 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8644 type Value = DropSchemaResponse;
8645
8646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8647 formatter.write_str("struct ddl_service.DropSchemaResponse")
8648 }
8649
8650 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
8651 where
8652 V: serde::de::MapAccess<'de>,
8653 {
8654 let mut status__ = None;
8655 let mut version__ = None;
8656 while let Some(k) = map_.next_key()? {
8657 match k {
8658 GeneratedField::Status => {
8659 if status__.is_some() {
8660 return Err(serde::de::Error::duplicate_field("status"));
8661 }
8662 status__ = map_.next_value()?;
8663 }
8664 GeneratedField::Version => {
8665 if version__.is_some() {
8666 return Err(serde::de::Error::duplicate_field("version"));
8667 }
8668 version__ = map_.next_value()?;
8669 }
8670 }
8671 }
8672 Ok(DropSchemaResponse {
8673 status: status__,
8674 version: version__,
8675 })
8676 }
8677 }
8678 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
8679 }
8680}
8681impl serde::Serialize for DropSecretRequest {
8682 #[allow(deprecated)]
8683 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8684 where
8685 S: serde::Serializer,
8686 {
8687 use serde::ser::SerializeStruct;
8688 let mut len = 0;
8689 if self.secret_id != 0 {
8690 len += 1;
8691 }
8692 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
8693 if self.secret_id != 0 {
8694 struct_ser.serialize_field("secretId", &self.secret_id)?;
8695 }
8696 struct_ser.end()
8697 }
8698}
8699impl<'de> serde::Deserialize<'de> for DropSecretRequest {
8700 #[allow(deprecated)]
8701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8702 where
8703 D: serde::Deserializer<'de>,
8704 {
8705 const FIELDS: &[&str] = &[
8706 "secret_id",
8707 "secretId",
8708 ];
8709
8710 #[allow(clippy::enum_variant_names)]
8711 enum GeneratedField {
8712 SecretId,
8713 }
8714 impl<'de> serde::Deserialize<'de> for GeneratedField {
8715 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8716 where
8717 D: serde::Deserializer<'de>,
8718 {
8719 struct GeneratedVisitor;
8720
8721 impl serde::de::Visitor<'_> for GeneratedVisitor {
8722 type Value = GeneratedField;
8723
8724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8725 write!(formatter, "expected one of: {:?}", &FIELDS)
8726 }
8727
8728 #[allow(unused_variables)]
8729 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8730 where
8731 E: serde::de::Error,
8732 {
8733 match value {
8734 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
8735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8736 }
8737 }
8738 }
8739 deserializer.deserialize_identifier(GeneratedVisitor)
8740 }
8741 }
8742 struct GeneratedVisitor;
8743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8744 type Value = DropSecretRequest;
8745
8746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8747 formatter.write_str("struct ddl_service.DropSecretRequest")
8748 }
8749
8750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
8751 where
8752 V: serde::de::MapAccess<'de>,
8753 {
8754 let mut secret_id__ = None;
8755 while let Some(k) = map_.next_key()? {
8756 match k {
8757 GeneratedField::SecretId => {
8758 if secret_id__.is_some() {
8759 return Err(serde::de::Error::duplicate_field("secretId"));
8760 }
8761 secret_id__ =
8762 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8763 ;
8764 }
8765 }
8766 }
8767 Ok(DropSecretRequest {
8768 secret_id: secret_id__.unwrap_or_default(),
8769 })
8770 }
8771 }
8772 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
8773 }
8774}
8775impl serde::Serialize for DropSecretResponse {
8776 #[allow(deprecated)]
8777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8778 where
8779 S: serde::Serializer,
8780 {
8781 use serde::ser::SerializeStruct;
8782 let mut len = 0;
8783 if self.version.is_some() {
8784 len += 1;
8785 }
8786 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
8787 if let Some(v) = self.version.as_ref() {
8788 struct_ser.serialize_field("version", v)?;
8789 }
8790 struct_ser.end()
8791 }
8792}
8793impl<'de> serde::Deserialize<'de> for DropSecretResponse {
8794 #[allow(deprecated)]
8795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8796 where
8797 D: serde::Deserializer<'de>,
8798 {
8799 const FIELDS: &[&str] = &[
8800 "version",
8801 ];
8802
8803 #[allow(clippy::enum_variant_names)]
8804 enum GeneratedField {
8805 Version,
8806 }
8807 impl<'de> serde::Deserialize<'de> for GeneratedField {
8808 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8809 where
8810 D: serde::Deserializer<'de>,
8811 {
8812 struct GeneratedVisitor;
8813
8814 impl serde::de::Visitor<'_> for GeneratedVisitor {
8815 type Value = GeneratedField;
8816
8817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8818 write!(formatter, "expected one of: {:?}", &FIELDS)
8819 }
8820
8821 #[allow(unused_variables)]
8822 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8823 where
8824 E: serde::de::Error,
8825 {
8826 match value {
8827 "version" => Ok(GeneratedField::Version),
8828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8829 }
8830 }
8831 }
8832 deserializer.deserialize_identifier(GeneratedVisitor)
8833 }
8834 }
8835 struct GeneratedVisitor;
8836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8837 type Value = DropSecretResponse;
8838
8839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8840 formatter.write_str("struct ddl_service.DropSecretResponse")
8841 }
8842
8843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
8844 where
8845 V: serde::de::MapAccess<'de>,
8846 {
8847 let mut version__ = None;
8848 while let Some(k) = map_.next_key()? {
8849 match k {
8850 GeneratedField::Version => {
8851 if version__.is_some() {
8852 return Err(serde::de::Error::duplicate_field("version"));
8853 }
8854 version__ = map_.next_value()?;
8855 }
8856 }
8857 }
8858 Ok(DropSecretResponse {
8859 version: version__,
8860 })
8861 }
8862 }
8863 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
8864 }
8865}
8866impl serde::Serialize for DropSinkRequest {
8867 #[allow(deprecated)]
8868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8869 where
8870 S: serde::Serializer,
8871 {
8872 use serde::ser::SerializeStruct;
8873 let mut len = 0;
8874 if self.sink_id != 0 {
8875 len += 1;
8876 }
8877 if self.cascade {
8878 len += 1;
8879 }
8880 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
8881 if self.sink_id != 0 {
8882 struct_ser.serialize_field("sinkId", &self.sink_id)?;
8883 }
8884 if self.cascade {
8885 struct_ser.serialize_field("cascade", &self.cascade)?;
8886 }
8887 struct_ser.end()
8888 }
8889}
8890impl<'de> serde::Deserialize<'de> for DropSinkRequest {
8891 #[allow(deprecated)]
8892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8893 where
8894 D: serde::Deserializer<'de>,
8895 {
8896 const FIELDS: &[&str] = &[
8897 "sink_id",
8898 "sinkId",
8899 "cascade",
8900 ];
8901
8902 #[allow(clippy::enum_variant_names)]
8903 enum GeneratedField {
8904 SinkId,
8905 Cascade,
8906 }
8907 impl<'de> serde::Deserialize<'de> for GeneratedField {
8908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8909 where
8910 D: serde::Deserializer<'de>,
8911 {
8912 struct GeneratedVisitor;
8913
8914 impl serde::de::Visitor<'_> for GeneratedVisitor {
8915 type Value = GeneratedField;
8916
8917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8918 write!(formatter, "expected one of: {:?}", &FIELDS)
8919 }
8920
8921 #[allow(unused_variables)]
8922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8923 where
8924 E: serde::de::Error,
8925 {
8926 match value {
8927 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
8928 "cascade" => Ok(GeneratedField::Cascade),
8929 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8930 }
8931 }
8932 }
8933 deserializer.deserialize_identifier(GeneratedVisitor)
8934 }
8935 }
8936 struct GeneratedVisitor;
8937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8938 type Value = DropSinkRequest;
8939
8940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8941 formatter.write_str("struct ddl_service.DropSinkRequest")
8942 }
8943
8944 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
8945 where
8946 V: serde::de::MapAccess<'de>,
8947 {
8948 let mut sink_id__ = None;
8949 let mut cascade__ = None;
8950 while let Some(k) = map_.next_key()? {
8951 match k {
8952 GeneratedField::SinkId => {
8953 if sink_id__.is_some() {
8954 return Err(serde::de::Error::duplicate_field("sinkId"));
8955 }
8956 sink_id__ =
8957 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8958 ;
8959 }
8960 GeneratedField::Cascade => {
8961 if cascade__.is_some() {
8962 return Err(serde::de::Error::duplicate_field("cascade"));
8963 }
8964 cascade__ = Some(map_.next_value()?);
8965 }
8966 }
8967 }
8968 Ok(DropSinkRequest {
8969 sink_id: sink_id__.unwrap_or_default(),
8970 cascade: cascade__.unwrap_or_default(),
8971 })
8972 }
8973 }
8974 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
8975 }
8976}
8977impl serde::Serialize for DropSinkResponse {
8978 #[allow(deprecated)]
8979 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8980 where
8981 S: serde::Serializer,
8982 {
8983 use serde::ser::SerializeStruct;
8984 let mut len = 0;
8985 if self.status.is_some() {
8986 len += 1;
8987 }
8988 if self.version.is_some() {
8989 len += 1;
8990 }
8991 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
8992 if let Some(v) = self.status.as_ref() {
8993 struct_ser.serialize_field("status", v)?;
8994 }
8995 if let Some(v) = self.version.as_ref() {
8996 struct_ser.serialize_field("version", v)?;
8997 }
8998 struct_ser.end()
8999 }
9000}
9001impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9002 #[allow(deprecated)]
9003 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9004 where
9005 D: serde::Deserializer<'de>,
9006 {
9007 const FIELDS: &[&str] = &[
9008 "status",
9009 "version",
9010 ];
9011
9012 #[allow(clippy::enum_variant_names)]
9013 enum GeneratedField {
9014 Status,
9015 Version,
9016 }
9017 impl<'de> serde::Deserialize<'de> for GeneratedField {
9018 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9019 where
9020 D: serde::Deserializer<'de>,
9021 {
9022 struct GeneratedVisitor;
9023
9024 impl serde::de::Visitor<'_> for GeneratedVisitor {
9025 type Value = GeneratedField;
9026
9027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9028 write!(formatter, "expected one of: {:?}", &FIELDS)
9029 }
9030
9031 #[allow(unused_variables)]
9032 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9033 where
9034 E: serde::de::Error,
9035 {
9036 match value {
9037 "status" => Ok(GeneratedField::Status),
9038 "version" => Ok(GeneratedField::Version),
9039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9040 }
9041 }
9042 }
9043 deserializer.deserialize_identifier(GeneratedVisitor)
9044 }
9045 }
9046 struct GeneratedVisitor;
9047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9048 type Value = DropSinkResponse;
9049
9050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9051 formatter.write_str("struct ddl_service.DropSinkResponse")
9052 }
9053
9054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9055 where
9056 V: serde::de::MapAccess<'de>,
9057 {
9058 let mut status__ = None;
9059 let mut version__ = None;
9060 while let Some(k) = map_.next_key()? {
9061 match k {
9062 GeneratedField::Status => {
9063 if status__.is_some() {
9064 return Err(serde::de::Error::duplicate_field("status"));
9065 }
9066 status__ = map_.next_value()?;
9067 }
9068 GeneratedField::Version => {
9069 if version__.is_some() {
9070 return Err(serde::de::Error::duplicate_field("version"));
9071 }
9072 version__ = map_.next_value()?;
9073 }
9074 }
9075 }
9076 Ok(DropSinkResponse {
9077 status: status__,
9078 version: version__,
9079 })
9080 }
9081 }
9082 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9083 }
9084}
9085impl serde::Serialize for DropSourceRequest {
9086 #[allow(deprecated)]
9087 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9088 where
9089 S: serde::Serializer,
9090 {
9091 use serde::ser::SerializeStruct;
9092 let mut len = 0;
9093 if self.source_id != 0 {
9094 len += 1;
9095 }
9096 if self.cascade {
9097 len += 1;
9098 }
9099 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9100 if self.source_id != 0 {
9101 struct_ser.serialize_field("sourceId", &self.source_id)?;
9102 }
9103 if self.cascade {
9104 struct_ser.serialize_field("cascade", &self.cascade)?;
9105 }
9106 struct_ser.end()
9107 }
9108}
9109impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9110 #[allow(deprecated)]
9111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9112 where
9113 D: serde::Deserializer<'de>,
9114 {
9115 const FIELDS: &[&str] = &[
9116 "source_id",
9117 "sourceId",
9118 "cascade",
9119 ];
9120
9121 #[allow(clippy::enum_variant_names)]
9122 enum GeneratedField {
9123 SourceId,
9124 Cascade,
9125 }
9126 impl<'de> serde::Deserialize<'de> for GeneratedField {
9127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9128 where
9129 D: serde::Deserializer<'de>,
9130 {
9131 struct GeneratedVisitor;
9132
9133 impl serde::de::Visitor<'_> for GeneratedVisitor {
9134 type Value = GeneratedField;
9135
9136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9137 write!(formatter, "expected one of: {:?}", &FIELDS)
9138 }
9139
9140 #[allow(unused_variables)]
9141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9142 where
9143 E: serde::de::Error,
9144 {
9145 match value {
9146 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9147 "cascade" => Ok(GeneratedField::Cascade),
9148 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9149 }
9150 }
9151 }
9152 deserializer.deserialize_identifier(GeneratedVisitor)
9153 }
9154 }
9155 struct GeneratedVisitor;
9156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9157 type Value = DropSourceRequest;
9158
9159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9160 formatter.write_str("struct ddl_service.DropSourceRequest")
9161 }
9162
9163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9164 where
9165 V: serde::de::MapAccess<'de>,
9166 {
9167 let mut source_id__ = None;
9168 let mut cascade__ = None;
9169 while let Some(k) = map_.next_key()? {
9170 match k {
9171 GeneratedField::SourceId => {
9172 if source_id__.is_some() {
9173 return Err(serde::de::Error::duplicate_field("sourceId"));
9174 }
9175 source_id__ =
9176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9177 ;
9178 }
9179 GeneratedField::Cascade => {
9180 if cascade__.is_some() {
9181 return Err(serde::de::Error::duplicate_field("cascade"));
9182 }
9183 cascade__ = Some(map_.next_value()?);
9184 }
9185 }
9186 }
9187 Ok(DropSourceRequest {
9188 source_id: source_id__.unwrap_or_default(),
9189 cascade: cascade__.unwrap_or_default(),
9190 })
9191 }
9192 }
9193 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
9194 }
9195}
9196impl serde::Serialize for DropSourceResponse {
9197 #[allow(deprecated)]
9198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9199 where
9200 S: serde::Serializer,
9201 {
9202 use serde::ser::SerializeStruct;
9203 let mut len = 0;
9204 if self.status.is_some() {
9205 len += 1;
9206 }
9207 if self.version.is_some() {
9208 len += 1;
9209 }
9210 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
9211 if let Some(v) = self.status.as_ref() {
9212 struct_ser.serialize_field("status", v)?;
9213 }
9214 if let Some(v) = self.version.as_ref() {
9215 struct_ser.serialize_field("version", v)?;
9216 }
9217 struct_ser.end()
9218 }
9219}
9220impl<'de> serde::Deserialize<'de> for DropSourceResponse {
9221 #[allow(deprecated)]
9222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9223 where
9224 D: serde::Deserializer<'de>,
9225 {
9226 const FIELDS: &[&str] = &[
9227 "status",
9228 "version",
9229 ];
9230
9231 #[allow(clippy::enum_variant_names)]
9232 enum GeneratedField {
9233 Status,
9234 Version,
9235 }
9236 impl<'de> serde::Deserialize<'de> for GeneratedField {
9237 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9238 where
9239 D: serde::Deserializer<'de>,
9240 {
9241 struct GeneratedVisitor;
9242
9243 impl serde::de::Visitor<'_> for GeneratedVisitor {
9244 type Value = GeneratedField;
9245
9246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9247 write!(formatter, "expected one of: {:?}", &FIELDS)
9248 }
9249
9250 #[allow(unused_variables)]
9251 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9252 where
9253 E: serde::de::Error,
9254 {
9255 match value {
9256 "status" => Ok(GeneratedField::Status),
9257 "version" => Ok(GeneratedField::Version),
9258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9259 }
9260 }
9261 }
9262 deserializer.deserialize_identifier(GeneratedVisitor)
9263 }
9264 }
9265 struct GeneratedVisitor;
9266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9267 type Value = DropSourceResponse;
9268
9269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9270 formatter.write_str("struct ddl_service.DropSourceResponse")
9271 }
9272
9273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9274 where
9275 V: serde::de::MapAccess<'de>,
9276 {
9277 let mut status__ = None;
9278 let mut version__ = None;
9279 while let Some(k) = map_.next_key()? {
9280 match k {
9281 GeneratedField::Status => {
9282 if status__.is_some() {
9283 return Err(serde::de::Error::duplicate_field("status"));
9284 }
9285 status__ = map_.next_value()?;
9286 }
9287 GeneratedField::Version => {
9288 if version__.is_some() {
9289 return Err(serde::de::Error::duplicate_field("version"));
9290 }
9291 version__ = map_.next_value()?;
9292 }
9293 }
9294 }
9295 Ok(DropSourceResponse {
9296 status: status__,
9297 version: version__,
9298 })
9299 }
9300 }
9301 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9302 }
9303}
9304impl serde::Serialize for DropSubscriptionRequest {
9305 #[allow(deprecated)]
9306 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9307 where
9308 S: serde::Serializer,
9309 {
9310 use serde::ser::SerializeStruct;
9311 let mut len = 0;
9312 if self.subscription_id != 0 {
9313 len += 1;
9314 }
9315 if self.cascade {
9316 len += 1;
9317 }
9318 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9319 if self.subscription_id != 0 {
9320 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9321 }
9322 if self.cascade {
9323 struct_ser.serialize_field("cascade", &self.cascade)?;
9324 }
9325 struct_ser.end()
9326 }
9327}
9328impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9329 #[allow(deprecated)]
9330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9331 where
9332 D: serde::Deserializer<'de>,
9333 {
9334 const FIELDS: &[&str] = &[
9335 "subscription_id",
9336 "subscriptionId",
9337 "cascade",
9338 ];
9339
9340 #[allow(clippy::enum_variant_names)]
9341 enum GeneratedField {
9342 SubscriptionId,
9343 Cascade,
9344 }
9345 impl<'de> serde::Deserialize<'de> for GeneratedField {
9346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9347 where
9348 D: serde::Deserializer<'de>,
9349 {
9350 struct GeneratedVisitor;
9351
9352 impl serde::de::Visitor<'_> for GeneratedVisitor {
9353 type Value = GeneratedField;
9354
9355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9356 write!(formatter, "expected one of: {:?}", &FIELDS)
9357 }
9358
9359 #[allow(unused_variables)]
9360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9361 where
9362 E: serde::de::Error,
9363 {
9364 match value {
9365 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9366 "cascade" => Ok(GeneratedField::Cascade),
9367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9368 }
9369 }
9370 }
9371 deserializer.deserialize_identifier(GeneratedVisitor)
9372 }
9373 }
9374 struct GeneratedVisitor;
9375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9376 type Value = DropSubscriptionRequest;
9377
9378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9379 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9380 }
9381
9382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9383 where
9384 V: serde::de::MapAccess<'de>,
9385 {
9386 let mut subscription_id__ = None;
9387 let mut cascade__ = None;
9388 while let Some(k) = map_.next_key()? {
9389 match k {
9390 GeneratedField::SubscriptionId => {
9391 if subscription_id__.is_some() {
9392 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9393 }
9394 subscription_id__ =
9395 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9396 ;
9397 }
9398 GeneratedField::Cascade => {
9399 if cascade__.is_some() {
9400 return Err(serde::de::Error::duplicate_field("cascade"));
9401 }
9402 cascade__ = Some(map_.next_value()?);
9403 }
9404 }
9405 }
9406 Ok(DropSubscriptionRequest {
9407 subscription_id: subscription_id__.unwrap_or_default(),
9408 cascade: cascade__.unwrap_or_default(),
9409 })
9410 }
9411 }
9412 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9413 }
9414}
9415impl serde::Serialize for DropSubscriptionResponse {
9416 #[allow(deprecated)]
9417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9418 where
9419 S: serde::Serializer,
9420 {
9421 use serde::ser::SerializeStruct;
9422 let mut len = 0;
9423 if self.status.is_some() {
9424 len += 1;
9425 }
9426 if self.version.is_some() {
9427 len += 1;
9428 }
9429 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9430 if let Some(v) = self.status.as_ref() {
9431 struct_ser.serialize_field("status", v)?;
9432 }
9433 if let Some(v) = self.version.as_ref() {
9434 struct_ser.serialize_field("version", v)?;
9435 }
9436 struct_ser.end()
9437 }
9438}
9439impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9440 #[allow(deprecated)]
9441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9442 where
9443 D: serde::Deserializer<'de>,
9444 {
9445 const FIELDS: &[&str] = &[
9446 "status",
9447 "version",
9448 ];
9449
9450 #[allow(clippy::enum_variant_names)]
9451 enum GeneratedField {
9452 Status,
9453 Version,
9454 }
9455 impl<'de> serde::Deserialize<'de> for GeneratedField {
9456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9457 where
9458 D: serde::Deserializer<'de>,
9459 {
9460 struct GeneratedVisitor;
9461
9462 impl serde::de::Visitor<'_> for GeneratedVisitor {
9463 type Value = GeneratedField;
9464
9465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9466 write!(formatter, "expected one of: {:?}", &FIELDS)
9467 }
9468
9469 #[allow(unused_variables)]
9470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9471 where
9472 E: serde::de::Error,
9473 {
9474 match value {
9475 "status" => Ok(GeneratedField::Status),
9476 "version" => Ok(GeneratedField::Version),
9477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9478 }
9479 }
9480 }
9481 deserializer.deserialize_identifier(GeneratedVisitor)
9482 }
9483 }
9484 struct GeneratedVisitor;
9485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9486 type Value = DropSubscriptionResponse;
9487
9488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9489 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
9490 }
9491
9492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
9493 where
9494 V: serde::de::MapAccess<'de>,
9495 {
9496 let mut status__ = None;
9497 let mut version__ = None;
9498 while let Some(k) = map_.next_key()? {
9499 match k {
9500 GeneratedField::Status => {
9501 if status__.is_some() {
9502 return Err(serde::de::Error::duplicate_field("status"));
9503 }
9504 status__ = map_.next_value()?;
9505 }
9506 GeneratedField::Version => {
9507 if version__.is_some() {
9508 return Err(serde::de::Error::duplicate_field("version"));
9509 }
9510 version__ = map_.next_value()?;
9511 }
9512 }
9513 }
9514 Ok(DropSubscriptionResponse {
9515 status: status__,
9516 version: version__,
9517 })
9518 }
9519 }
9520 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
9521 }
9522}
9523impl serde::Serialize for DropTableRequest {
9524 #[allow(deprecated)]
9525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9526 where
9527 S: serde::Serializer,
9528 {
9529 use serde::ser::SerializeStruct;
9530 let mut len = 0;
9531 if self.table_id != 0 {
9532 len += 1;
9533 }
9534 if self.cascade {
9535 len += 1;
9536 }
9537 if self.source_id.is_some() {
9538 len += 1;
9539 }
9540 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
9541 if self.table_id != 0 {
9542 struct_ser.serialize_field("tableId", &self.table_id)?;
9543 }
9544 if self.cascade {
9545 struct_ser.serialize_field("cascade", &self.cascade)?;
9546 }
9547 if let Some(v) = self.source_id.as_ref() {
9548 match v {
9549 drop_table_request::SourceId::Id(v) => {
9550 struct_ser.serialize_field("id", v)?;
9551 }
9552 }
9553 }
9554 struct_ser.end()
9555 }
9556}
9557impl<'de> serde::Deserialize<'de> for DropTableRequest {
9558 #[allow(deprecated)]
9559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9560 where
9561 D: serde::Deserializer<'de>,
9562 {
9563 const FIELDS: &[&str] = &[
9564 "table_id",
9565 "tableId",
9566 "cascade",
9567 "id",
9568 ];
9569
9570 #[allow(clippy::enum_variant_names)]
9571 enum GeneratedField {
9572 TableId,
9573 Cascade,
9574 Id,
9575 }
9576 impl<'de> serde::Deserialize<'de> for GeneratedField {
9577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9578 where
9579 D: serde::Deserializer<'de>,
9580 {
9581 struct GeneratedVisitor;
9582
9583 impl serde::de::Visitor<'_> for GeneratedVisitor {
9584 type Value = GeneratedField;
9585
9586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9587 write!(formatter, "expected one of: {:?}", &FIELDS)
9588 }
9589
9590 #[allow(unused_variables)]
9591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9592 where
9593 E: serde::de::Error,
9594 {
9595 match value {
9596 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9597 "cascade" => Ok(GeneratedField::Cascade),
9598 "id" => Ok(GeneratedField::Id),
9599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9600 }
9601 }
9602 }
9603 deserializer.deserialize_identifier(GeneratedVisitor)
9604 }
9605 }
9606 struct GeneratedVisitor;
9607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9608 type Value = DropTableRequest;
9609
9610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9611 formatter.write_str("struct ddl_service.DropTableRequest")
9612 }
9613
9614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
9615 where
9616 V: serde::de::MapAccess<'de>,
9617 {
9618 let mut table_id__ = None;
9619 let mut cascade__ = None;
9620 let mut source_id__ = None;
9621 while let Some(k) = map_.next_key()? {
9622 match k {
9623 GeneratedField::TableId => {
9624 if table_id__.is_some() {
9625 return Err(serde::de::Error::duplicate_field("tableId"));
9626 }
9627 table_id__ =
9628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9629 ;
9630 }
9631 GeneratedField::Cascade => {
9632 if cascade__.is_some() {
9633 return Err(serde::de::Error::duplicate_field("cascade"));
9634 }
9635 cascade__ = Some(map_.next_value()?);
9636 }
9637 GeneratedField::Id => {
9638 if source_id__.is_some() {
9639 return Err(serde::de::Error::duplicate_field("id"));
9640 }
9641 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
9642 }
9643 }
9644 }
9645 Ok(DropTableRequest {
9646 table_id: table_id__.unwrap_or_default(),
9647 cascade: cascade__.unwrap_or_default(),
9648 source_id: source_id__,
9649 })
9650 }
9651 }
9652 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
9653 }
9654}
9655impl serde::Serialize for DropTableResponse {
9656 #[allow(deprecated)]
9657 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9658 where
9659 S: serde::Serializer,
9660 {
9661 use serde::ser::SerializeStruct;
9662 let mut len = 0;
9663 if self.status.is_some() {
9664 len += 1;
9665 }
9666 if self.version.is_some() {
9667 len += 1;
9668 }
9669 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
9670 if let Some(v) = self.status.as_ref() {
9671 struct_ser.serialize_field("status", v)?;
9672 }
9673 if let Some(v) = self.version.as_ref() {
9674 struct_ser.serialize_field("version", v)?;
9675 }
9676 struct_ser.end()
9677 }
9678}
9679impl<'de> serde::Deserialize<'de> for DropTableResponse {
9680 #[allow(deprecated)]
9681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9682 where
9683 D: serde::Deserializer<'de>,
9684 {
9685 const FIELDS: &[&str] = &[
9686 "status",
9687 "version",
9688 ];
9689
9690 #[allow(clippy::enum_variant_names)]
9691 enum GeneratedField {
9692 Status,
9693 Version,
9694 }
9695 impl<'de> serde::Deserialize<'de> for GeneratedField {
9696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9697 where
9698 D: serde::Deserializer<'de>,
9699 {
9700 struct GeneratedVisitor;
9701
9702 impl serde::de::Visitor<'_> for GeneratedVisitor {
9703 type Value = GeneratedField;
9704
9705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9706 write!(formatter, "expected one of: {:?}", &FIELDS)
9707 }
9708
9709 #[allow(unused_variables)]
9710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9711 where
9712 E: serde::de::Error,
9713 {
9714 match value {
9715 "status" => Ok(GeneratedField::Status),
9716 "version" => Ok(GeneratedField::Version),
9717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9718 }
9719 }
9720 }
9721 deserializer.deserialize_identifier(GeneratedVisitor)
9722 }
9723 }
9724 struct GeneratedVisitor;
9725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9726 type Value = DropTableResponse;
9727
9728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9729 formatter.write_str("struct ddl_service.DropTableResponse")
9730 }
9731
9732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
9733 where
9734 V: serde::de::MapAccess<'de>,
9735 {
9736 let mut status__ = None;
9737 let mut version__ = None;
9738 while let Some(k) = map_.next_key()? {
9739 match k {
9740 GeneratedField::Status => {
9741 if status__.is_some() {
9742 return Err(serde::de::Error::duplicate_field("status"));
9743 }
9744 status__ = map_.next_value()?;
9745 }
9746 GeneratedField::Version => {
9747 if version__.is_some() {
9748 return Err(serde::de::Error::duplicate_field("version"));
9749 }
9750 version__ = map_.next_value()?;
9751 }
9752 }
9753 }
9754 Ok(DropTableResponse {
9755 status: status__,
9756 version: version__,
9757 })
9758 }
9759 }
9760 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
9761 }
9762}
9763impl serde::Serialize for DropViewRequest {
9764 #[allow(deprecated)]
9765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9766 where
9767 S: serde::Serializer,
9768 {
9769 use serde::ser::SerializeStruct;
9770 let mut len = 0;
9771 if self.view_id != 0 {
9772 len += 1;
9773 }
9774 if self.cascade {
9775 len += 1;
9776 }
9777 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
9778 if self.view_id != 0 {
9779 struct_ser.serialize_field("viewId", &self.view_id)?;
9780 }
9781 if self.cascade {
9782 struct_ser.serialize_field("cascade", &self.cascade)?;
9783 }
9784 struct_ser.end()
9785 }
9786}
9787impl<'de> serde::Deserialize<'de> for DropViewRequest {
9788 #[allow(deprecated)]
9789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9790 where
9791 D: serde::Deserializer<'de>,
9792 {
9793 const FIELDS: &[&str] = &[
9794 "view_id",
9795 "viewId",
9796 "cascade",
9797 ];
9798
9799 #[allow(clippy::enum_variant_names)]
9800 enum GeneratedField {
9801 ViewId,
9802 Cascade,
9803 }
9804 impl<'de> serde::Deserialize<'de> for GeneratedField {
9805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9806 where
9807 D: serde::Deserializer<'de>,
9808 {
9809 struct GeneratedVisitor;
9810
9811 impl serde::de::Visitor<'_> for GeneratedVisitor {
9812 type Value = GeneratedField;
9813
9814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9815 write!(formatter, "expected one of: {:?}", &FIELDS)
9816 }
9817
9818 #[allow(unused_variables)]
9819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9820 where
9821 E: serde::de::Error,
9822 {
9823 match value {
9824 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
9825 "cascade" => Ok(GeneratedField::Cascade),
9826 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9827 }
9828 }
9829 }
9830 deserializer.deserialize_identifier(GeneratedVisitor)
9831 }
9832 }
9833 struct GeneratedVisitor;
9834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9835 type Value = DropViewRequest;
9836
9837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9838 formatter.write_str("struct ddl_service.DropViewRequest")
9839 }
9840
9841 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
9842 where
9843 V: serde::de::MapAccess<'de>,
9844 {
9845 let mut view_id__ = None;
9846 let mut cascade__ = None;
9847 while let Some(k) = map_.next_key()? {
9848 match k {
9849 GeneratedField::ViewId => {
9850 if view_id__.is_some() {
9851 return Err(serde::de::Error::duplicate_field("viewId"));
9852 }
9853 view_id__ =
9854 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9855 ;
9856 }
9857 GeneratedField::Cascade => {
9858 if cascade__.is_some() {
9859 return Err(serde::de::Error::duplicate_field("cascade"));
9860 }
9861 cascade__ = Some(map_.next_value()?);
9862 }
9863 }
9864 }
9865 Ok(DropViewRequest {
9866 view_id: view_id__.unwrap_or_default(),
9867 cascade: cascade__.unwrap_or_default(),
9868 })
9869 }
9870 }
9871 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
9872 }
9873}
9874impl serde::Serialize for DropViewResponse {
9875 #[allow(deprecated)]
9876 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9877 where
9878 S: serde::Serializer,
9879 {
9880 use serde::ser::SerializeStruct;
9881 let mut len = 0;
9882 if self.status.is_some() {
9883 len += 1;
9884 }
9885 if self.version.is_some() {
9886 len += 1;
9887 }
9888 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
9889 if let Some(v) = self.status.as_ref() {
9890 struct_ser.serialize_field("status", v)?;
9891 }
9892 if let Some(v) = self.version.as_ref() {
9893 struct_ser.serialize_field("version", v)?;
9894 }
9895 struct_ser.end()
9896 }
9897}
9898impl<'de> serde::Deserialize<'de> for DropViewResponse {
9899 #[allow(deprecated)]
9900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9901 where
9902 D: serde::Deserializer<'de>,
9903 {
9904 const FIELDS: &[&str] = &[
9905 "status",
9906 "version",
9907 ];
9908
9909 #[allow(clippy::enum_variant_names)]
9910 enum GeneratedField {
9911 Status,
9912 Version,
9913 }
9914 impl<'de> serde::Deserialize<'de> for GeneratedField {
9915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9916 where
9917 D: serde::Deserializer<'de>,
9918 {
9919 struct GeneratedVisitor;
9920
9921 impl serde::de::Visitor<'_> for GeneratedVisitor {
9922 type Value = GeneratedField;
9923
9924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9925 write!(formatter, "expected one of: {:?}", &FIELDS)
9926 }
9927
9928 #[allow(unused_variables)]
9929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9930 where
9931 E: serde::de::Error,
9932 {
9933 match value {
9934 "status" => Ok(GeneratedField::Status),
9935 "version" => Ok(GeneratedField::Version),
9936 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9937 }
9938 }
9939 }
9940 deserializer.deserialize_identifier(GeneratedVisitor)
9941 }
9942 }
9943 struct GeneratedVisitor;
9944 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9945 type Value = DropViewResponse;
9946
9947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9948 formatter.write_str("struct ddl_service.DropViewResponse")
9949 }
9950
9951 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
9952 where
9953 V: serde::de::MapAccess<'de>,
9954 {
9955 let mut status__ = None;
9956 let mut version__ = None;
9957 while let Some(k) = map_.next_key()? {
9958 match k {
9959 GeneratedField::Status => {
9960 if status__.is_some() {
9961 return Err(serde::de::Error::duplicate_field("status"));
9962 }
9963 status__ = map_.next_value()?;
9964 }
9965 GeneratedField::Version => {
9966 if version__.is_some() {
9967 return Err(serde::de::Error::duplicate_field("version"));
9968 }
9969 version__ = map_.next_value()?;
9970 }
9971 }
9972 }
9973 Ok(DropViewResponse {
9974 status: status__,
9975 version: version__,
9976 })
9977 }
9978 }
9979 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
9980 }
9981}
9982impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
9983 #[allow(deprecated)]
9984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9985 where
9986 S: serde::Serializer,
9987 {
9988 use serde::ser::SerializeStruct;
9989 let mut len = 0;
9990 if self.sink_id != 0 {
9991 len += 1;
9992 }
9993 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
9994 if self.sink_id != 0 {
9995 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9996 }
9997 struct_ser.end()
9998 }
9999}
10000impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10001 #[allow(deprecated)]
10002 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10003 where
10004 D: serde::Deserializer<'de>,
10005 {
10006 const FIELDS: &[&str] = &[
10007 "sink_id",
10008 "sinkId",
10009 ];
10010
10011 #[allow(clippy::enum_variant_names)]
10012 enum GeneratedField {
10013 SinkId,
10014 }
10015 impl<'de> serde::Deserialize<'de> for GeneratedField {
10016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10017 where
10018 D: serde::Deserializer<'de>,
10019 {
10020 struct GeneratedVisitor;
10021
10022 impl serde::de::Visitor<'_> for GeneratedVisitor {
10023 type Value = GeneratedField;
10024
10025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10026 write!(formatter, "expected one of: {:?}", &FIELDS)
10027 }
10028
10029 #[allow(unused_variables)]
10030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10031 where
10032 E: serde::de::Error,
10033 {
10034 match value {
10035 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10036 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10037 }
10038 }
10039 }
10040 deserializer.deserialize_identifier(GeneratedVisitor)
10041 }
10042 }
10043 struct GeneratedVisitor;
10044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10045 type Value = ExpireIcebergTableSnapshotsRequest;
10046
10047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10048 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10049 }
10050
10051 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10052 where
10053 V: serde::de::MapAccess<'de>,
10054 {
10055 let mut sink_id__ = None;
10056 while let Some(k) = map_.next_key()? {
10057 match k {
10058 GeneratedField::SinkId => {
10059 if sink_id__.is_some() {
10060 return Err(serde::de::Error::duplicate_field("sinkId"));
10061 }
10062 sink_id__ =
10063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10064 ;
10065 }
10066 }
10067 }
10068 Ok(ExpireIcebergTableSnapshotsRequest {
10069 sink_id: sink_id__.unwrap_or_default(),
10070 })
10071 }
10072 }
10073 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10074 }
10075}
10076impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10077 #[allow(deprecated)]
10078 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10079 where
10080 S: serde::Serializer,
10081 {
10082 use serde::ser::SerializeStruct;
10083 let mut len = 0;
10084 if self.status.is_some() {
10085 len += 1;
10086 }
10087 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10088 if let Some(v) = self.status.as_ref() {
10089 struct_ser.serialize_field("status", v)?;
10090 }
10091 struct_ser.end()
10092 }
10093}
10094impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10095 #[allow(deprecated)]
10096 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10097 where
10098 D: serde::Deserializer<'de>,
10099 {
10100 const FIELDS: &[&str] = &[
10101 "status",
10102 ];
10103
10104 #[allow(clippy::enum_variant_names)]
10105 enum GeneratedField {
10106 Status,
10107 }
10108 impl<'de> serde::Deserialize<'de> for GeneratedField {
10109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10110 where
10111 D: serde::Deserializer<'de>,
10112 {
10113 struct GeneratedVisitor;
10114
10115 impl serde::de::Visitor<'_> for GeneratedVisitor {
10116 type Value = GeneratedField;
10117
10118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10119 write!(formatter, "expected one of: {:?}", &FIELDS)
10120 }
10121
10122 #[allow(unused_variables)]
10123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10124 where
10125 E: serde::de::Error,
10126 {
10127 match value {
10128 "status" => Ok(GeneratedField::Status),
10129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10130 }
10131 }
10132 }
10133 deserializer.deserialize_identifier(GeneratedVisitor)
10134 }
10135 }
10136 struct GeneratedVisitor;
10137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10138 type Value = ExpireIcebergTableSnapshotsResponse;
10139
10140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10141 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10142 }
10143
10144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10145 where
10146 V: serde::de::MapAccess<'de>,
10147 {
10148 let mut status__ = None;
10149 while let Some(k) = map_.next_key()? {
10150 match k {
10151 GeneratedField::Status => {
10152 if status__.is_some() {
10153 return Err(serde::de::Error::duplicate_field("status"));
10154 }
10155 status__ = map_.next_value()?;
10156 }
10157 }
10158 }
10159 Ok(ExpireIcebergTableSnapshotsResponse {
10160 status: status__,
10161 })
10162 }
10163 }
10164 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10165 }
10166}
10167impl serde::Serialize for GetDdlProgressRequest {
10168 #[allow(deprecated)]
10169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10170 where
10171 S: serde::Serializer,
10172 {
10173 use serde::ser::SerializeStruct;
10174 let len = 0;
10175 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10176 struct_ser.end()
10177 }
10178}
10179impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10180 #[allow(deprecated)]
10181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10182 where
10183 D: serde::Deserializer<'de>,
10184 {
10185 const FIELDS: &[&str] = &[
10186 ];
10187
10188 #[allow(clippy::enum_variant_names)]
10189 enum GeneratedField {
10190 }
10191 impl<'de> serde::Deserialize<'de> for GeneratedField {
10192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10193 where
10194 D: serde::Deserializer<'de>,
10195 {
10196 struct GeneratedVisitor;
10197
10198 impl serde::de::Visitor<'_> for GeneratedVisitor {
10199 type Value = GeneratedField;
10200
10201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10202 write!(formatter, "expected one of: {:?}", &FIELDS)
10203 }
10204
10205 #[allow(unused_variables)]
10206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10207 where
10208 E: serde::de::Error,
10209 {
10210 Err(serde::de::Error::unknown_field(value, FIELDS))
10211 }
10212 }
10213 deserializer.deserialize_identifier(GeneratedVisitor)
10214 }
10215 }
10216 struct GeneratedVisitor;
10217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10218 type Value = GetDdlProgressRequest;
10219
10220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10221 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
10222 }
10223
10224 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
10225 where
10226 V: serde::de::MapAccess<'de>,
10227 {
10228 while map_.next_key::<GeneratedField>()?.is_some() {
10229 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10230 }
10231 Ok(GetDdlProgressRequest {
10232 })
10233 }
10234 }
10235 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
10236 }
10237}
10238impl serde::Serialize for GetDdlProgressResponse {
10239 #[allow(deprecated)]
10240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10241 where
10242 S: serde::Serializer,
10243 {
10244 use serde::ser::SerializeStruct;
10245 let mut len = 0;
10246 if !self.ddl_progress.is_empty() {
10247 len += 1;
10248 }
10249 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
10250 if !self.ddl_progress.is_empty() {
10251 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
10252 }
10253 struct_ser.end()
10254 }
10255}
10256impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
10257 #[allow(deprecated)]
10258 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10259 where
10260 D: serde::Deserializer<'de>,
10261 {
10262 const FIELDS: &[&str] = &[
10263 "ddl_progress",
10264 "ddlProgress",
10265 ];
10266
10267 #[allow(clippy::enum_variant_names)]
10268 enum GeneratedField {
10269 DdlProgress,
10270 }
10271 impl<'de> serde::Deserialize<'de> for GeneratedField {
10272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10273 where
10274 D: serde::Deserializer<'de>,
10275 {
10276 struct GeneratedVisitor;
10277
10278 impl serde::de::Visitor<'_> for GeneratedVisitor {
10279 type Value = GeneratedField;
10280
10281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10282 write!(formatter, "expected one of: {:?}", &FIELDS)
10283 }
10284
10285 #[allow(unused_variables)]
10286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10287 where
10288 E: serde::de::Error,
10289 {
10290 match value {
10291 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10292 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10293 }
10294 }
10295 }
10296 deserializer.deserialize_identifier(GeneratedVisitor)
10297 }
10298 }
10299 struct GeneratedVisitor;
10300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10301 type Value = GetDdlProgressResponse;
10302
10303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10304 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10305 }
10306
10307 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10308 where
10309 V: serde::de::MapAccess<'de>,
10310 {
10311 let mut ddl_progress__ = None;
10312 while let Some(k) = map_.next_key()? {
10313 match k {
10314 GeneratedField::DdlProgress => {
10315 if ddl_progress__.is_some() {
10316 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10317 }
10318 ddl_progress__ = Some(map_.next_value()?);
10319 }
10320 }
10321 }
10322 Ok(GetDdlProgressResponse {
10323 ddl_progress: ddl_progress__.unwrap_or_default(),
10324 })
10325 }
10326 }
10327 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10328 }
10329}
10330impl serde::Serialize for GetTableRequest {
10331 #[allow(deprecated)]
10332 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10333 where
10334 S: serde::Serializer,
10335 {
10336 use serde::ser::SerializeStruct;
10337 let mut len = 0;
10338 if !self.database_name.is_empty() {
10339 len += 1;
10340 }
10341 if !self.table_name.is_empty() {
10342 len += 1;
10343 }
10344 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10345 if !self.database_name.is_empty() {
10346 struct_ser.serialize_field("databaseName", &self.database_name)?;
10347 }
10348 if !self.table_name.is_empty() {
10349 struct_ser.serialize_field("tableName", &self.table_name)?;
10350 }
10351 struct_ser.end()
10352 }
10353}
10354impl<'de> serde::Deserialize<'de> for GetTableRequest {
10355 #[allow(deprecated)]
10356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10357 where
10358 D: serde::Deserializer<'de>,
10359 {
10360 const FIELDS: &[&str] = &[
10361 "database_name",
10362 "databaseName",
10363 "table_name",
10364 "tableName",
10365 ];
10366
10367 #[allow(clippy::enum_variant_names)]
10368 enum GeneratedField {
10369 DatabaseName,
10370 TableName,
10371 }
10372 impl<'de> serde::Deserialize<'de> for GeneratedField {
10373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10374 where
10375 D: serde::Deserializer<'de>,
10376 {
10377 struct GeneratedVisitor;
10378
10379 impl serde::de::Visitor<'_> for GeneratedVisitor {
10380 type Value = GeneratedField;
10381
10382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10383 write!(formatter, "expected one of: {:?}", &FIELDS)
10384 }
10385
10386 #[allow(unused_variables)]
10387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10388 where
10389 E: serde::de::Error,
10390 {
10391 match value {
10392 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10393 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10395 }
10396 }
10397 }
10398 deserializer.deserialize_identifier(GeneratedVisitor)
10399 }
10400 }
10401 struct GeneratedVisitor;
10402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10403 type Value = GetTableRequest;
10404
10405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10406 formatter.write_str("struct ddl_service.GetTableRequest")
10407 }
10408
10409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10410 where
10411 V: serde::de::MapAccess<'de>,
10412 {
10413 let mut database_name__ = None;
10414 let mut table_name__ = None;
10415 while let Some(k) = map_.next_key()? {
10416 match k {
10417 GeneratedField::DatabaseName => {
10418 if database_name__.is_some() {
10419 return Err(serde::de::Error::duplicate_field("databaseName"));
10420 }
10421 database_name__ = Some(map_.next_value()?);
10422 }
10423 GeneratedField::TableName => {
10424 if table_name__.is_some() {
10425 return Err(serde::de::Error::duplicate_field("tableName"));
10426 }
10427 table_name__ = Some(map_.next_value()?);
10428 }
10429 }
10430 }
10431 Ok(GetTableRequest {
10432 database_name: database_name__.unwrap_or_default(),
10433 table_name: table_name__.unwrap_or_default(),
10434 })
10435 }
10436 }
10437 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10438 }
10439}
10440impl serde::Serialize for GetTableResponse {
10441 #[allow(deprecated)]
10442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10443 where
10444 S: serde::Serializer,
10445 {
10446 use serde::ser::SerializeStruct;
10447 let mut len = 0;
10448 if self.table.is_some() {
10449 len += 1;
10450 }
10451 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10452 if let Some(v) = self.table.as_ref() {
10453 struct_ser.serialize_field("table", v)?;
10454 }
10455 struct_ser.end()
10456 }
10457}
10458impl<'de> serde::Deserialize<'de> for GetTableResponse {
10459 #[allow(deprecated)]
10460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10461 where
10462 D: serde::Deserializer<'de>,
10463 {
10464 const FIELDS: &[&str] = &[
10465 "table",
10466 ];
10467
10468 #[allow(clippy::enum_variant_names)]
10469 enum GeneratedField {
10470 Table,
10471 }
10472 impl<'de> serde::Deserialize<'de> for GeneratedField {
10473 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10474 where
10475 D: serde::Deserializer<'de>,
10476 {
10477 struct GeneratedVisitor;
10478
10479 impl serde::de::Visitor<'_> for GeneratedVisitor {
10480 type Value = GeneratedField;
10481
10482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10483 write!(formatter, "expected one of: {:?}", &FIELDS)
10484 }
10485
10486 #[allow(unused_variables)]
10487 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10488 where
10489 E: serde::de::Error,
10490 {
10491 match value {
10492 "table" => Ok(GeneratedField::Table),
10493 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10494 }
10495 }
10496 }
10497 deserializer.deserialize_identifier(GeneratedVisitor)
10498 }
10499 }
10500 struct GeneratedVisitor;
10501 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10502 type Value = GetTableResponse;
10503
10504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10505 formatter.write_str("struct ddl_service.GetTableResponse")
10506 }
10507
10508 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
10509 where
10510 V: serde::de::MapAccess<'de>,
10511 {
10512 let mut table__ = None;
10513 while let Some(k) = map_.next_key()? {
10514 match k {
10515 GeneratedField::Table => {
10516 if table__.is_some() {
10517 return Err(serde::de::Error::duplicate_field("table"));
10518 }
10519 table__ = map_.next_value()?;
10520 }
10521 }
10522 }
10523 Ok(GetTableResponse {
10524 table: table__,
10525 })
10526 }
10527 }
10528 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
10529 }
10530}
10531impl serde::Serialize for GetTablesRequest {
10532 #[allow(deprecated)]
10533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10534 where
10535 S: serde::Serializer,
10536 {
10537 use serde::ser::SerializeStruct;
10538 let mut len = 0;
10539 if !self.table_ids.is_empty() {
10540 len += 1;
10541 }
10542 if self.include_dropped_tables {
10543 len += 1;
10544 }
10545 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
10546 if !self.table_ids.is_empty() {
10547 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10548 }
10549 if self.include_dropped_tables {
10550 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
10551 }
10552 struct_ser.end()
10553 }
10554}
10555impl<'de> serde::Deserialize<'de> for GetTablesRequest {
10556 #[allow(deprecated)]
10557 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10558 where
10559 D: serde::Deserializer<'de>,
10560 {
10561 const FIELDS: &[&str] = &[
10562 "table_ids",
10563 "tableIds",
10564 "include_dropped_tables",
10565 "includeDroppedTables",
10566 ];
10567
10568 #[allow(clippy::enum_variant_names)]
10569 enum GeneratedField {
10570 TableIds,
10571 IncludeDroppedTables,
10572 }
10573 impl<'de> serde::Deserialize<'de> for GeneratedField {
10574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10575 where
10576 D: serde::Deserializer<'de>,
10577 {
10578 struct GeneratedVisitor;
10579
10580 impl serde::de::Visitor<'_> for GeneratedVisitor {
10581 type Value = GeneratedField;
10582
10583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10584 write!(formatter, "expected one of: {:?}", &FIELDS)
10585 }
10586
10587 #[allow(unused_variables)]
10588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10589 where
10590 E: serde::de::Error,
10591 {
10592 match value {
10593 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10594 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
10595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10596 }
10597 }
10598 }
10599 deserializer.deserialize_identifier(GeneratedVisitor)
10600 }
10601 }
10602 struct GeneratedVisitor;
10603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10604 type Value = GetTablesRequest;
10605
10606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10607 formatter.write_str("struct ddl_service.GetTablesRequest")
10608 }
10609
10610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
10611 where
10612 V: serde::de::MapAccess<'de>,
10613 {
10614 let mut table_ids__ = None;
10615 let mut include_dropped_tables__ = None;
10616 while let Some(k) = map_.next_key()? {
10617 match k {
10618 GeneratedField::TableIds => {
10619 if table_ids__.is_some() {
10620 return Err(serde::de::Error::duplicate_field("tableIds"));
10621 }
10622 table_ids__ =
10623 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10624 .into_iter().map(|x| x.0).collect())
10625 ;
10626 }
10627 GeneratedField::IncludeDroppedTables => {
10628 if include_dropped_tables__.is_some() {
10629 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
10630 }
10631 include_dropped_tables__ = Some(map_.next_value()?);
10632 }
10633 }
10634 }
10635 Ok(GetTablesRequest {
10636 table_ids: table_ids__.unwrap_or_default(),
10637 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
10638 })
10639 }
10640 }
10641 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
10642 }
10643}
10644impl serde::Serialize for GetTablesResponse {
10645 #[allow(deprecated)]
10646 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10647 where
10648 S: serde::Serializer,
10649 {
10650 use serde::ser::SerializeStruct;
10651 let mut len = 0;
10652 if !self.tables.is_empty() {
10653 len += 1;
10654 }
10655 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
10656 if !self.tables.is_empty() {
10657 struct_ser.serialize_field("tables", &self.tables)?;
10658 }
10659 struct_ser.end()
10660 }
10661}
10662impl<'de> serde::Deserialize<'de> for GetTablesResponse {
10663 #[allow(deprecated)]
10664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10665 where
10666 D: serde::Deserializer<'de>,
10667 {
10668 const FIELDS: &[&str] = &[
10669 "tables",
10670 ];
10671
10672 #[allow(clippy::enum_variant_names)]
10673 enum GeneratedField {
10674 Tables,
10675 }
10676 impl<'de> serde::Deserialize<'de> for GeneratedField {
10677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10678 where
10679 D: serde::Deserializer<'de>,
10680 {
10681 struct GeneratedVisitor;
10682
10683 impl serde::de::Visitor<'_> for GeneratedVisitor {
10684 type Value = GeneratedField;
10685
10686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10687 write!(formatter, "expected one of: {:?}", &FIELDS)
10688 }
10689
10690 #[allow(unused_variables)]
10691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10692 where
10693 E: serde::de::Error,
10694 {
10695 match value {
10696 "tables" => Ok(GeneratedField::Tables),
10697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10698 }
10699 }
10700 }
10701 deserializer.deserialize_identifier(GeneratedVisitor)
10702 }
10703 }
10704 struct GeneratedVisitor;
10705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10706 type Value = GetTablesResponse;
10707
10708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10709 formatter.write_str("struct ddl_service.GetTablesResponse")
10710 }
10711
10712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
10713 where
10714 V: serde::de::MapAccess<'de>,
10715 {
10716 let mut tables__ = None;
10717 while let Some(k) = map_.next_key()? {
10718 match k {
10719 GeneratedField::Tables => {
10720 if tables__.is_some() {
10721 return Err(serde::de::Error::duplicate_field("tables"));
10722 }
10723 tables__ = Some(
10724 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10725 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10726 );
10727 }
10728 }
10729 }
10730 Ok(GetTablesResponse {
10731 tables: tables__.unwrap_or_default(),
10732 })
10733 }
10734 }
10735 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
10736 }
10737}
10738impl serde::Serialize for ListConnectionsRequest {
10739 #[allow(deprecated)]
10740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10741 where
10742 S: serde::Serializer,
10743 {
10744 use serde::ser::SerializeStruct;
10745 let len = 0;
10746 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
10747 struct_ser.end()
10748 }
10749}
10750impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
10751 #[allow(deprecated)]
10752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10753 where
10754 D: serde::Deserializer<'de>,
10755 {
10756 const FIELDS: &[&str] = &[
10757 ];
10758
10759 #[allow(clippy::enum_variant_names)]
10760 enum GeneratedField {
10761 }
10762 impl<'de> serde::Deserialize<'de> for GeneratedField {
10763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10764 where
10765 D: serde::Deserializer<'de>,
10766 {
10767 struct GeneratedVisitor;
10768
10769 impl serde::de::Visitor<'_> for GeneratedVisitor {
10770 type Value = GeneratedField;
10771
10772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10773 write!(formatter, "expected one of: {:?}", &FIELDS)
10774 }
10775
10776 #[allow(unused_variables)]
10777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10778 where
10779 E: serde::de::Error,
10780 {
10781 Err(serde::de::Error::unknown_field(value, FIELDS))
10782 }
10783 }
10784 deserializer.deserialize_identifier(GeneratedVisitor)
10785 }
10786 }
10787 struct GeneratedVisitor;
10788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10789 type Value = ListConnectionsRequest;
10790
10791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10792 formatter.write_str("struct ddl_service.ListConnectionsRequest")
10793 }
10794
10795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
10796 where
10797 V: serde::de::MapAccess<'de>,
10798 {
10799 while map_.next_key::<GeneratedField>()?.is_some() {
10800 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10801 }
10802 Ok(ListConnectionsRequest {
10803 })
10804 }
10805 }
10806 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
10807 }
10808}
10809impl serde::Serialize for ListConnectionsResponse {
10810 #[allow(deprecated)]
10811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10812 where
10813 S: serde::Serializer,
10814 {
10815 use serde::ser::SerializeStruct;
10816 let mut len = 0;
10817 if !self.connections.is_empty() {
10818 len += 1;
10819 }
10820 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
10821 if !self.connections.is_empty() {
10822 struct_ser.serialize_field("connections", &self.connections)?;
10823 }
10824 struct_ser.end()
10825 }
10826}
10827impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
10828 #[allow(deprecated)]
10829 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10830 where
10831 D: serde::Deserializer<'de>,
10832 {
10833 const FIELDS: &[&str] = &[
10834 "connections",
10835 ];
10836
10837 #[allow(clippy::enum_variant_names)]
10838 enum GeneratedField {
10839 Connections,
10840 }
10841 impl<'de> serde::Deserialize<'de> for GeneratedField {
10842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10843 where
10844 D: serde::Deserializer<'de>,
10845 {
10846 struct GeneratedVisitor;
10847
10848 impl serde::de::Visitor<'_> for GeneratedVisitor {
10849 type Value = GeneratedField;
10850
10851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10852 write!(formatter, "expected one of: {:?}", &FIELDS)
10853 }
10854
10855 #[allow(unused_variables)]
10856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10857 where
10858 E: serde::de::Error,
10859 {
10860 match value {
10861 "connections" => Ok(GeneratedField::Connections),
10862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10863 }
10864 }
10865 }
10866 deserializer.deserialize_identifier(GeneratedVisitor)
10867 }
10868 }
10869 struct GeneratedVisitor;
10870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10871 type Value = ListConnectionsResponse;
10872
10873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10874 formatter.write_str("struct ddl_service.ListConnectionsResponse")
10875 }
10876
10877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
10878 where
10879 V: serde::de::MapAccess<'de>,
10880 {
10881 let mut connections__ = None;
10882 while let Some(k) = map_.next_key()? {
10883 match k {
10884 GeneratedField::Connections => {
10885 if connections__.is_some() {
10886 return Err(serde::de::Error::duplicate_field("connections"));
10887 }
10888 connections__ = Some(map_.next_value()?);
10889 }
10890 }
10891 }
10892 Ok(ListConnectionsResponse {
10893 connections: connections__.unwrap_or_default(),
10894 })
10895 }
10896 }
10897 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
10898 }
10899}
10900impl serde::Serialize for ReplaceJobPlan {
10901 #[allow(deprecated)]
10902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10903 where
10904 S: serde::Serializer,
10905 {
10906 use serde::ser::SerializeStruct;
10907 let mut len = 0;
10908 if self.fragment_graph.is_some() {
10909 len += 1;
10910 }
10911 if self.replace_job.is_some() {
10912 len += 1;
10913 }
10914 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
10915 if let Some(v) = self.fragment_graph.as_ref() {
10916 struct_ser.serialize_field("fragmentGraph", v)?;
10917 }
10918 if let Some(v) = self.replace_job.as_ref() {
10919 match v {
10920 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
10921 struct_ser.serialize_field("replaceTable", v)?;
10922 }
10923 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
10924 struct_ser.serialize_field("replaceSource", v)?;
10925 }
10926 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
10927 struct_ser.serialize_field("replaceMaterializedView", v)?;
10928 }
10929 }
10930 }
10931 struct_ser.end()
10932 }
10933}
10934impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
10935 #[allow(deprecated)]
10936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10937 where
10938 D: serde::Deserializer<'de>,
10939 {
10940 const FIELDS: &[&str] = &[
10941 "fragment_graph",
10942 "fragmentGraph",
10943 "replace_table",
10944 "replaceTable",
10945 "replace_source",
10946 "replaceSource",
10947 "replace_materialized_view",
10948 "replaceMaterializedView",
10949 ];
10950
10951 #[allow(clippy::enum_variant_names)]
10952 enum GeneratedField {
10953 FragmentGraph,
10954 ReplaceTable,
10955 ReplaceSource,
10956 ReplaceMaterializedView,
10957 }
10958 impl<'de> serde::Deserialize<'de> for GeneratedField {
10959 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10960 where
10961 D: serde::Deserializer<'de>,
10962 {
10963 struct GeneratedVisitor;
10964
10965 impl serde::de::Visitor<'_> for GeneratedVisitor {
10966 type Value = GeneratedField;
10967
10968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10969 write!(formatter, "expected one of: {:?}", &FIELDS)
10970 }
10971
10972 #[allow(unused_variables)]
10973 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10974 where
10975 E: serde::de::Error,
10976 {
10977 match value {
10978 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
10979 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
10980 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
10981 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
10982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10983 }
10984 }
10985 }
10986 deserializer.deserialize_identifier(GeneratedVisitor)
10987 }
10988 }
10989 struct GeneratedVisitor;
10990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10991 type Value = ReplaceJobPlan;
10992
10993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10994 formatter.write_str("struct ddl_service.ReplaceJobPlan")
10995 }
10996
10997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
10998 where
10999 V: serde::de::MapAccess<'de>,
11000 {
11001 let mut fragment_graph__ = None;
11002 let mut replace_job__ = None;
11003 while let Some(k) = map_.next_key()? {
11004 match k {
11005 GeneratedField::FragmentGraph => {
11006 if fragment_graph__.is_some() {
11007 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11008 }
11009 fragment_graph__ = map_.next_value()?;
11010 }
11011 GeneratedField::ReplaceTable => {
11012 if replace_job__.is_some() {
11013 return Err(serde::de::Error::duplicate_field("replaceTable"));
11014 }
11015 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11016;
11017 }
11018 GeneratedField::ReplaceSource => {
11019 if replace_job__.is_some() {
11020 return Err(serde::de::Error::duplicate_field("replaceSource"));
11021 }
11022 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11023;
11024 }
11025 GeneratedField::ReplaceMaterializedView => {
11026 if replace_job__.is_some() {
11027 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11028 }
11029 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11030;
11031 }
11032 }
11033 }
11034 Ok(ReplaceJobPlan {
11035 fragment_graph: fragment_graph__,
11036 replace_job: replace_job__,
11037 })
11038 }
11039 }
11040 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11041 }
11042}
11043impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
11044 #[allow(deprecated)]
11045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11046 where
11047 S: serde::Serializer,
11048 {
11049 use serde::ser::SerializeStruct;
11050 let mut len = 0;
11051 if self.table.is_some() {
11052 len += 1;
11053 }
11054 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11055 if let Some(v) = self.table.as_ref() {
11056 struct_ser.serialize_field("table", v)?;
11057 }
11058 struct_ser.end()
11059 }
11060}
11061impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
11062 #[allow(deprecated)]
11063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11064 where
11065 D: serde::Deserializer<'de>,
11066 {
11067 const FIELDS: &[&str] = &[
11068 "table",
11069 ];
11070
11071 #[allow(clippy::enum_variant_names)]
11072 enum GeneratedField {
11073 Table,
11074 }
11075 impl<'de> serde::Deserialize<'de> for GeneratedField {
11076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11077 where
11078 D: serde::Deserializer<'de>,
11079 {
11080 struct GeneratedVisitor;
11081
11082 impl serde::de::Visitor<'_> for GeneratedVisitor {
11083 type Value = GeneratedField;
11084
11085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11086 write!(formatter, "expected one of: {:?}", &FIELDS)
11087 }
11088
11089 #[allow(unused_variables)]
11090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11091 where
11092 E: serde::de::Error,
11093 {
11094 match value {
11095 "table" => Ok(GeneratedField::Table),
11096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11097 }
11098 }
11099 }
11100 deserializer.deserialize_identifier(GeneratedVisitor)
11101 }
11102 }
11103 struct GeneratedVisitor;
11104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11105 type Value = replace_job_plan::ReplaceMaterializedView;
11106
11107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11108 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11109 }
11110
11111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11112 where
11113 V: serde::de::MapAccess<'de>,
11114 {
11115 let mut table__ = None;
11116 while let Some(k) = map_.next_key()? {
11117 match k {
11118 GeneratedField::Table => {
11119 if table__.is_some() {
11120 return Err(serde::de::Error::duplicate_field("table"));
11121 }
11122 table__ = map_.next_value()?;
11123 }
11124 }
11125 }
11126 Ok(replace_job_plan::ReplaceMaterializedView {
11127 table: table__,
11128 })
11129 }
11130 }
11131 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11132 }
11133}
11134impl serde::Serialize for replace_job_plan::ReplaceSource {
11135 #[allow(deprecated)]
11136 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11137 where
11138 S: serde::Serializer,
11139 {
11140 use serde::ser::SerializeStruct;
11141 let mut len = 0;
11142 if self.source.is_some() {
11143 len += 1;
11144 }
11145 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11146 if let Some(v) = self.source.as_ref() {
11147 struct_ser.serialize_field("source", v)?;
11148 }
11149 struct_ser.end()
11150 }
11151}
11152impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11153 #[allow(deprecated)]
11154 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11155 where
11156 D: serde::Deserializer<'de>,
11157 {
11158 const FIELDS: &[&str] = &[
11159 "source",
11160 ];
11161
11162 #[allow(clippy::enum_variant_names)]
11163 enum GeneratedField {
11164 Source,
11165 }
11166 impl<'de> serde::Deserialize<'de> for GeneratedField {
11167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11168 where
11169 D: serde::Deserializer<'de>,
11170 {
11171 struct GeneratedVisitor;
11172
11173 impl serde::de::Visitor<'_> for GeneratedVisitor {
11174 type Value = GeneratedField;
11175
11176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11177 write!(formatter, "expected one of: {:?}", &FIELDS)
11178 }
11179
11180 #[allow(unused_variables)]
11181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11182 where
11183 E: serde::de::Error,
11184 {
11185 match value {
11186 "source" => Ok(GeneratedField::Source),
11187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11188 }
11189 }
11190 }
11191 deserializer.deserialize_identifier(GeneratedVisitor)
11192 }
11193 }
11194 struct GeneratedVisitor;
11195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11196 type Value = replace_job_plan::ReplaceSource;
11197
11198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11199 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
11200 }
11201
11202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
11203 where
11204 V: serde::de::MapAccess<'de>,
11205 {
11206 let mut source__ = None;
11207 while let Some(k) = map_.next_key()? {
11208 match k {
11209 GeneratedField::Source => {
11210 if source__.is_some() {
11211 return Err(serde::de::Error::duplicate_field("source"));
11212 }
11213 source__ = map_.next_value()?;
11214 }
11215 }
11216 }
11217 Ok(replace_job_plan::ReplaceSource {
11218 source: source__,
11219 })
11220 }
11221 }
11222 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
11223 }
11224}
11225impl serde::Serialize for replace_job_plan::ReplaceTable {
11226 #[allow(deprecated)]
11227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11228 where
11229 S: serde::Serializer,
11230 {
11231 use serde::ser::SerializeStruct;
11232 let mut len = 0;
11233 if self.table.is_some() {
11234 len += 1;
11235 }
11236 if self.source.is_some() {
11237 len += 1;
11238 }
11239 if self.job_type != 0 {
11240 len += 1;
11241 }
11242 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
11243 if let Some(v) = self.table.as_ref() {
11244 struct_ser.serialize_field("table", v)?;
11245 }
11246 if let Some(v) = self.source.as_ref() {
11247 struct_ser.serialize_field("source", v)?;
11248 }
11249 if self.job_type != 0 {
11250 let v = TableJobType::try_from(self.job_type)
11251 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
11252 struct_ser.serialize_field("jobType", &v)?;
11253 }
11254 struct_ser.end()
11255 }
11256}
11257impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
11258 #[allow(deprecated)]
11259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11260 where
11261 D: serde::Deserializer<'de>,
11262 {
11263 const FIELDS: &[&str] = &[
11264 "table",
11265 "source",
11266 "job_type",
11267 "jobType",
11268 ];
11269
11270 #[allow(clippy::enum_variant_names)]
11271 enum GeneratedField {
11272 Table,
11273 Source,
11274 JobType,
11275 }
11276 impl<'de> serde::Deserialize<'de> for GeneratedField {
11277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11278 where
11279 D: serde::Deserializer<'de>,
11280 {
11281 struct GeneratedVisitor;
11282
11283 impl serde::de::Visitor<'_> for GeneratedVisitor {
11284 type Value = GeneratedField;
11285
11286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11287 write!(formatter, "expected one of: {:?}", &FIELDS)
11288 }
11289
11290 #[allow(unused_variables)]
11291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11292 where
11293 E: serde::de::Error,
11294 {
11295 match value {
11296 "table" => Ok(GeneratedField::Table),
11297 "source" => Ok(GeneratedField::Source),
11298 "jobType" | "job_type" => Ok(GeneratedField::JobType),
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 = replace_job_plan::ReplaceTable;
11309
11310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11311 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11312 }
11313
11314 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11315 where
11316 V: serde::de::MapAccess<'de>,
11317 {
11318 let mut table__ = None;
11319 let mut source__ = None;
11320 let mut job_type__ = None;
11321 while let Some(k) = map_.next_key()? {
11322 match k {
11323 GeneratedField::Table => {
11324 if table__.is_some() {
11325 return Err(serde::de::Error::duplicate_field("table"));
11326 }
11327 table__ = map_.next_value()?;
11328 }
11329 GeneratedField::Source => {
11330 if source__.is_some() {
11331 return Err(serde::de::Error::duplicate_field("source"));
11332 }
11333 source__ = map_.next_value()?;
11334 }
11335 GeneratedField::JobType => {
11336 if job_type__.is_some() {
11337 return Err(serde::de::Error::duplicate_field("jobType"));
11338 }
11339 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11340 }
11341 }
11342 }
11343 Ok(replace_job_plan::ReplaceTable {
11344 table: table__,
11345 source: source__,
11346 job_type: job_type__.unwrap_or_default(),
11347 })
11348 }
11349 }
11350 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11351 }
11352}
11353impl serde::Serialize for ReplaceJobPlanRequest {
11354 #[allow(deprecated)]
11355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11356 where
11357 S: serde::Serializer,
11358 {
11359 use serde::ser::SerializeStruct;
11360 let mut len = 0;
11361 if self.plan.is_some() {
11362 len += 1;
11363 }
11364 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11365 if let Some(v) = self.plan.as_ref() {
11366 struct_ser.serialize_field("plan", v)?;
11367 }
11368 struct_ser.end()
11369 }
11370}
11371impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11372 #[allow(deprecated)]
11373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11374 where
11375 D: serde::Deserializer<'de>,
11376 {
11377 const FIELDS: &[&str] = &[
11378 "plan",
11379 ];
11380
11381 #[allow(clippy::enum_variant_names)]
11382 enum GeneratedField {
11383 Plan,
11384 }
11385 impl<'de> serde::Deserialize<'de> for GeneratedField {
11386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11387 where
11388 D: serde::Deserializer<'de>,
11389 {
11390 struct GeneratedVisitor;
11391
11392 impl serde::de::Visitor<'_> for GeneratedVisitor {
11393 type Value = GeneratedField;
11394
11395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11396 write!(formatter, "expected one of: {:?}", &FIELDS)
11397 }
11398
11399 #[allow(unused_variables)]
11400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11401 where
11402 E: serde::de::Error,
11403 {
11404 match value {
11405 "plan" => Ok(GeneratedField::Plan),
11406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11407 }
11408 }
11409 }
11410 deserializer.deserialize_identifier(GeneratedVisitor)
11411 }
11412 }
11413 struct GeneratedVisitor;
11414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11415 type Value = ReplaceJobPlanRequest;
11416
11417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11418 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11419 }
11420
11421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11422 where
11423 V: serde::de::MapAccess<'de>,
11424 {
11425 let mut plan__ = None;
11426 while let Some(k) = map_.next_key()? {
11427 match k {
11428 GeneratedField::Plan => {
11429 if plan__.is_some() {
11430 return Err(serde::de::Error::duplicate_field("plan"));
11431 }
11432 plan__ = map_.next_value()?;
11433 }
11434 }
11435 }
11436 Ok(ReplaceJobPlanRequest {
11437 plan: plan__,
11438 })
11439 }
11440 }
11441 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11442 }
11443}
11444impl serde::Serialize for ReplaceJobPlanResponse {
11445 #[allow(deprecated)]
11446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11447 where
11448 S: serde::Serializer,
11449 {
11450 use serde::ser::SerializeStruct;
11451 let mut len = 0;
11452 if self.status.is_some() {
11453 len += 1;
11454 }
11455 if self.version.is_some() {
11456 len += 1;
11457 }
11458 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11459 if let Some(v) = self.status.as_ref() {
11460 struct_ser.serialize_field("status", v)?;
11461 }
11462 if let Some(v) = self.version.as_ref() {
11463 struct_ser.serialize_field("version", v)?;
11464 }
11465 struct_ser.end()
11466 }
11467}
11468impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
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 "status",
11476 "version",
11477 ];
11478
11479 #[allow(clippy::enum_variant_names)]
11480 enum GeneratedField {
11481 Status,
11482 Version,
11483 }
11484 impl<'de> serde::Deserialize<'de> for GeneratedField {
11485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11486 where
11487 D: serde::Deserializer<'de>,
11488 {
11489 struct GeneratedVisitor;
11490
11491 impl serde::de::Visitor<'_> for GeneratedVisitor {
11492 type Value = GeneratedField;
11493
11494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11495 write!(formatter, "expected one of: {:?}", &FIELDS)
11496 }
11497
11498 #[allow(unused_variables)]
11499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11500 where
11501 E: serde::de::Error,
11502 {
11503 match value {
11504 "status" => Ok(GeneratedField::Status),
11505 "version" => Ok(GeneratedField::Version),
11506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11507 }
11508 }
11509 }
11510 deserializer.deserialize_identifier(GeneratedVisitor)
11511 }
11512 }
11513 struct GeneratedVisitor;
11514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11515 type Value = ReplaceJobPlanResponse;
11516
11517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11518 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
11519 }
11520
11521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
11522 where
11523 V: serde::de::MapAccess<'de>,
11524 {
11525 let mut status__ = None;
11526 let mut version__ = None;
11527 while let Some(k) = map_.next_key()? {
11528 match k {
11529 GeneratedField::Status => {
11530 if status__.is_some() {
11531 return Err(serde::de::Error::duplicate_field("status"));
11532 }
11533 status__ = map_.next_value()?;
11534 }
11535 GeneratedField::Version => {
11536 if version__.is_some() {
11537 return Err(serde::de::Error::duplicate_field("version"));
11538 }
11539 version__ = map_.next_value()?;
11540 }
11541 }
11542 }
11543 Ok(ReplaceJobPlanResponse {
11544 status: status__,
11545 version: version__,
11546 })
11547 }
11548 }
11549 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
11550 }
11551}
11552impl serde::Serialize for ResetSourceRequest {
11553 #[allow(deprecated)]
11554 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11555 where
11556 S: serde::Serializer,
11557 {
11558 use serde::ser::SerializeStruct;
11559 let mut len = 0;
11560 if self.source_id != 0 {
11561 len += 1;
11562 }
11563 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
11564 if self.source_id != 0 {
11565 struct_ser.serialize_field("sourceId", &self.source_id)?;
11566 }
11567 struct_ser.end()
11568 }
11569}
11570impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
11571 #[allow(deprecated)]
11572 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11573 where
11574 D: serde::Deserializer<'de>,
11575 {
11576 const FIELDS: &[&str] = &[
11577 "source_id",
11578 "sourceId",
11579 ];
11580
11581 #[allow(clippy::enum_variant_names)]
11582 enum GeneratedField {
11583 SourceId,
11584 }
11585 impl<'de> serde::Deserialize<'de> for GeneratedField {
11586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11587 where
11588 D: serde::Deserializer<'de>,
11589 {
11590 struct GeneratedVisitor;
11591
11592 impl serde::de::Visitor<'_> for GeneratedVisitor {
11593 type Value = GeneratedField;
11594
11595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11596 write!(formatter, "expected one of: {:?}", &FIELDS)
11597 }
11598
11599 #[allow(unused_variables)]
11600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11601 where
11602 E: serde::de::Error,
11603 {
11604 match value {
11605 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11606 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11607 }
11608 }
11609 }
11610 deserializer.deserialize_identifier(GeneratedVisitor)
11611 }
11612 }
11613 struct GeneratedVisitor;
11614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11615 type Value = ResetSourceRequest;
11616
11617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11618 formatter.write_str("struct ddl_service.ResetSourceRequest")
11619 }
11620
11621 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
11622 where
11623 V: serde::de::MapAccess<'de>,
11624 {
11625 let mut source_id__ = None;
11626 while let Some(k) = map_.next_key()? {
11627 match k {
11628 GeneratedField::SourceId => {
11629 if source_id__.is_some() {
11630 return Err(serde::de::Error::duplicate_field("sourceId"));
11631 }
11632 source_id__ =
11633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11634 ;
11635 }
11636 }
11637 }
11638 Ok(ResetSourceRequest {
11639 source_id: source_id__.unwrap_or_default(),
11640 })
11641 }
11642 }
11643 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
11644 }
11645}
11646impl serde::Serialize for ResetSourceResponse {
11647 #[allow(deprecated)]
11648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11649 where
11650 S: serde::Serializer,
11651 {
11652 use serde::ser::SerializeStruct;
11653 let mut len = 0;
11654 if self.status.is_some() {
11655 len += 1;
11656 }
11657 if self.version.is_some() {
11658 len += 1;
11659 }
11660 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
11661 if let Some(v) = self.status.as_ref() {
11662 struct_ser.serialize_field("status", v)?;
11663 }
11664 if let Some(v) = self.version.as_ref() {
11665 struct_ser.serialize_field("version", v)?;
11666 }
11667 struct_ser.end()
11668 }
11669}
11670impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
11671 #[allow(deprecated)]
11672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11673 where
11674 D: serde::Deserializer<'de>,
11675 {
11676 const FIELDS: &[&str] = &[
11677 "status",
11678 "version",
11679 ];
11680
11681 #[allow(clippy::enum_variant_names)]
11682 enum GeneratedField {
11683 Status,
11684 Version,
11685 }
11686 impl<'de> serde::Deserialize<'de> for GeneratedField {
11687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11688 where
11689 D: serde::Deserializer<'de>,
11690 {
11691 struct GeneratedVisitor;
11692
11693 impl serde::de::Visitor<'_> for GeneratedVisitor {
11694 type Value = GeneratedField;
11695
11696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11697 write!(formatter, "expected one of: {:?}", &FIELDS)
11698 }
11699
11700 #[allow(unused_variables)]
11701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11702 where
11703 E: serde::de::Error,
11704 {
11705 match value {
11706 "status" => Ok(GeneratedField::Status),
11707 "version" => Ok(GeneratedField::Version),
11708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11709 }
11710 }
11711 }
11712 deserializer.deserialize_identifier(GeneratedVisitor)
11713 }
11714 }
11715 struct GeneratedVisitor;
11716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11717 type Value = ResetSourceResponse;
11718
11719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11720 formatter.write_str("struct ddl_service.ResetSourceResponse")
11721 }
11722
11723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
11724 where
11725 V: serde::de::MapAccess<'de>,
11726 {
11727 let mut status__ = None;
11728 let mut version__ = None;
11729 while let Some(k) = map_.next_key()? {
11730 match k {
11731 GeneratedField::Status => {
11732 if status__.is_some() {
11733 return Err(serde::de::Error::duplicate_field("status"));
11734 }
11735 status__ = map_.next_value()?;
11736 }
11737 GeneratedField::Version => {
11738 if version__.is_some() {
11739 return Err(serde::de::Error::duplicate_field("version"));
11740 }
11741 version__ = map_.next_value()?;
11742 }
11743 }
11744 }
11745 Ok(ResetSourceResponse {
11746 status: status__,
11747 version: version__,
11748 })
11749 }
11750 }
11751 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
11752 }
11753}
11754impl serde::Serialize for RisectlListStateTablesRequest {
11755 #[allow(deprecated)]
11756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11757 where
11758 S: serde::Serializer,
11759 {
11760 use serde::ser::SerializeStruct;
11761 let len = 0;
11762 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
11763 struct_ser.end()
11764 }
11765}
11766impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
11767 #[allow(deprecated)]
11768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11769 where
11770 D: serde::Deserializer<'de>,
11771 {
11772 const FIELDS: &[&str] = &[
11773 ];
11774
11775 #[allow(clippy::enum_variant_names)]
11776 enum GeneratedField {
11777 }
11778 impl<'de> serde::Deserialize<'de> for GeneratedField {
11779 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11780 where
11781 D: serde::Deserializer<'de>,
11782 {
11783 struct GeneratedVisitor;
11784
11785 impl serde::de::Visitor<'_> for GeneratedVisitor {
11786 type Value = GeneratedField;
11787
11788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11789 write!(formatter, "expected one of: {:?}", &FIELDS)
11790 }
11791
11792 #[allow(unused_variables)]
11793 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11794 where
11795 E: serde::de::Error,
11796 {
11797 Err(serde::de::Error::unknown_field(value, FIELDS))
11798 }
11799 }
11800 deserializer.deserialize_identifier(GeneratedVisitor)
11801 }
11802 }
11803 struct GeneratedVisitor;
11804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11805 type Value = RisectlListStateTablesRequest;
11806
11807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11808 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
11809 }
11810
11811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
11812 where
11813 V: serde::de::MapAccess<'de>,
11814 {
11815 while map_.next_key::<GeneratedField>()?.is_some() {
11816 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11817 }
11818 Ok(RisectlListStateTablesRequest {
11819 })
11820 }
11821 }
11822 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
11823 }
11824}
11825impl serde::Serialize for RisectlListStateTablesResponse {
11826 #[allow(deprecated)]
11827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11828 where
11829 S: serde::Serializer,
11830 {
11831 use serde::ser::SerializeStruct;
11832 let mut len = 0;
11833 if !self.tables.is_empty() {
11834 len += 1;
11835 }
11836 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
11837 if !self.tables.is_empty() {
11838 struct_ser.serialize_field("tables", &self.tables)?;
11839 }
11840 struct_ser.end()
11841 }
11842}
11843impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
11844 #[allow(deprecated)]
11845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11846 where
11847 D: serde::Deserializer<'de>,
11848 {
11849 const FIELDS: &[&str] = &[
11850 "tables",
11851 ];
11852
11853 #[allow(clippy::enum_variant_names)]
11854 enum GeneratedField {
11855 Tables,
11856 }
11857 impl<'de> serde::Deserialize<'de> for GeneratedField {
11858 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11859 where
11860 D: serde::Deserializer<'de>,
11861 {
11862 struct GeneratedVisitor;
11863
11864 impl serde::de::Visitor<'_> for GeneratedVisitor {
11865 type Value = GeneratedField;
11866
11867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11868 write!(formatter, "expected one of: {:?}", &FIELDS)
11869 }
11870
11871 #[allow(unused_variables)]
11872 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11873 where
11874 E: serde::de::Error,
11875 {
11876 match value {
11877 "tables" => Ok(GeneratedField::Tables),
11878 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11879 }
11880 }
11881 }
11882 deserializer.deserialize_identifier(GeneratedVisitor)
11883 }
11884 }
11885 struct GeneratedVisitor;
11886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11887 type Value = RisectlListStateTablesResponse;
11888
11889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11890 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
11891 }
11892
11893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
11894 where
11895 V: serde::de::MapAccess<'de>,
11896 {
11897 let mut tables__ = None;
11898 while let Some(k) = map_.next_key()? {
11899 match k {
11900 GeneratedField::Tables => {
11901 if tables__.is_some() {
11902 return Err(serde::de::Error::duplicate_field("tables"));
11903 }
11904 tables__ = Some(map_.next_value()?);
11905 }
11906 }
11907 }
11908 Ok(RisectlListStateTablesResponse {
11909 tables: tables__.unwrap_or_default(),
11910 })
11911 }
11912 }
11913 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
11914 }
11915}
11916impl serde::Serialize for SchemaChangeEnvelope {
11917 #[allow(deprecated)]
11918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11919 where
11920 S: serde::Serializer,
11921 {
11922 use serde::ser::SerializeStruct;
11923 let mut len = 0;
11924 if !self.table_changes.is_empty() {
11925 len += 1;
11926 }
11927 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
11928 if !self.table_changes.is_empty() {
11929 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
11930 }
11931 struct_ser.end()
11932 }
11933}
11934impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
11935 #[allow(deprecated)]
11936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11937 where
11938 D: serde::Deserializer<'de>,
11939 {
11940 const FIELDS: &[&str] = &[
11941 "table_changes",
11942 "tableChanges",
11943 ];
11944
11945 #[allow(clippy::enum_variant_names)]
11946 enum GeneratedField {
11947 TableChanges,
11948 }
11949 impl<'de> serde::Deserialize<'de> for GeneratedField {
11950 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11951 where
11952 D: serde::Deserializer<'de>,
11953 {
11954 struct GeneratedVisitor;
11955
11956 impl serde::de::Visitor<'_> for GeneratedVisitor {
11957 type Value = GeneratedField;
11958
11959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11960 write!(formatter, "expected one of: {:?}", &FIELDS)
11961 }
11962
11963 #[allow(unused_variables)]
11964 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11965 where
11966 E: serde::de::Error,
11967 {
11968 match value {
11969 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
11970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11971 }
11972 }
11973 }
11974 deserializer.deserialize_identifier(GeneratedVisitor)
11975 }
11976 }
11977 struct GeneratedVisitor;
11978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11979 type Value = SchemaChangeEnvelope;
11980
11981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11982 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
11983 }
11984
11985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
11986 where
11987 V: serde::de::MapAccess<'de>,
11988 {
11989 let mut table_changes__ = None;
11990 while let Some(k) = map_.next_key()? {
11991 match k {
11992 GeneratedField::TableChanges => {
11993 if table_changes__.is_some() {
11994 return Err(serde::de::Error::duplicate_field("tableChanges"));
11995 }
11996 table_changes__ = Some(map_.next_value()?);
11997 }
11998 }
11999 }
12000 Ok(SchemaChangeEnvelope {
12001 table_changes: table_changes__.unwrap_or_default(),
12002 })
12003 }
12004 }
12005 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
12006 }
12007}
12008impl serde::Serialize for StreamingJobResourceType {
12009 #[allow(deprecated)]
12010 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12011 where
12012 S: serde::Serializer,
12013 {
12014 use serde::ser::SerializeStruct;
12015 let mut len = 0;
12016 if self.resource_type.is_some() {
12017 len += 1;
12018 }
12019 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
12020 if let Some(v) = self.resource_type.as_ref() {
12021 match v {
12022 streaming_job_resource_type::ResourceType::Regular(v) => {
12023 struct_ser.serialize_field("regular", v)?;
12024 }
12025 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
12026 struct_ser.serialize_field("specificResourceGroup", v)?;
12027 }
12028 streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup(v) => {
12029 struct_ser.serialize_field("serverlessBackfillResourceGroup", v)?;
12030 }
12031 }
12032 }
12033 struct_ser.end()
12034 }
12035}
12036impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
12037 #[allow(deprecated)]
12038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12039 where
12040 D: serde::Deserializer<'de>,
12041 {
12042 const FIELDS: &[&str] = &[
12043 "regular",
12044 "specific_resource_group",
12045 "specificResourceGroup",
12046 "serverless_backfill_resource_group",
12047 "serverlessBackfillResourceGroup",
12048 ];
12049
12050 #[allow(clippy::enum_variant_names)]
12051 enum GeneratedField {
12052 Regular,
12053 SpecificResourceGroup,
12054 ServerlessBackfillResourceGroup,
12055 }
12056 impl<'de> serde::Deserialize<'de> for GeneratedField {
12057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12058 where
12059 D: serde::Deserializer<'de>,
12060 {
12061 struct GeneratedVisitor;
12062
12063 impl serde::de::Visitor<'_> for GeneratedVisitor {
12064 type Value = GeneratedField;
12065
12066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12067 write!(formatter, "expected one of: {:?}", &FIELDS)
12068 }
12069
12070 #[allow(unused_variables)]
12071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12072 where
12073 E: serde::de::Error,
12074 {
12075 match value {
12076 "regular" => Ok(GeneratedField::Regular),
12077 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
12078 "serverlessBackfillResourceGroup" | "serverless_backfill_resource_group" => Ok(GeneratedField::ServerlessBackfillResourceGroup),
12079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12080 }
12081 }
12082 }
12083 deserializer.deserialize_identifier(GeneratedVisitor)
12084 }
12085 }
12086 struct GeneratedVisitor;
12087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12088 type Value = StreamingJobResourceType;
12089
12090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12091 formatter.write_str("struct ddl_service.StreamingJobResourceType")
12092 }
12093
12094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
12095 where
12096 V: serde::de::MapAccess<'de>,
12097 {
12098 let mut resource_type__ = None;
12099 while let Some(k) = map_.next_key()? {
12100 match k {
12101 GeneratedField::Regular => {
12102 if resource_type__.is_some() {
12103 return Err(serde::de::Error::duplicate_field("regular"));
12104 }
12105 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
12106 }
12107 GeneratedField::SpecificResourceGroup => {
12108 if resource_type__.is_some() {
12109 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
12110 }
12111 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
12112 }
12113 GeneratedField::ServerlessBackfillResourceGroup => {
12114 if resource_type__.is_some() {
12115 return Err(serde::de::Error::duplicate_field("serverlessBackfillResourceGroup"));
12116 }
12117 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup);
12118 }
12119 }
12120 }
12121 Ok(StreamingJobResourceType {
12122 resource_type: resource_type__,
12123 })
12124 }
12125 }
12126 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
12127 }
12128}
12129impl serde::Serialize for TableJobType {
12130 #[allow(deprecated)]
12131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12132 where
12133 S: serde::Serializer,
12134 {
12135 let variant = match self {
12136 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
12137 Self::General => "TABLE_JOB_TYPE_GENERAL",
12138 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12139 };
12140 serializer.serialize_str(variant)
12141 }
12142}
12143impl<'de> serde::Deserialize<'de> for TableJobType {
12144 #[allow(deprecated)]
12145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12146 where
12147 D: serde::Deserializer<'de>,
12148 {
12149 const FIELDS: &[&str] = &[
12150 "TABLE_JOB_TYPE_UNSPECIFIED",
12151 "TABLE_JOB_TYPE_GENERAL",
12152 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12153 ];
12154
12155 struct GeneratedVisitor;
12156
12157 impl serde::de::Visitor<'_> for GeneratedVisitor {
12158 type Value = TableJobType;
12159
12160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12161 write!(formatter, "expected one of: {:?}", &FIELDS)
12162 }
12163
12164 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12165 where
12166 E: serde::de::Error,
12167 {
12168 i32::try_from(v)
12169 .ok()
12170 .and_then(|x| x.try_into().ok())
12171 .ok_or_else(|| {
12172 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12173 })
12174 }
12175
12176 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12177 where
12178 E: serde::de::Error,
12179 {
12180 i32::try_from(v)
12181 .ok()
12182 .and_then(|x| x.try_into().ok())
12183 .ok_or_else(|| {
12184 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12185 })
12186 }
12187
12188 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12189 where
12190 E: serde::de::Error,
12191 {
12192 match value {
12193 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
12194 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
12195 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
12196 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12197 }
12198 }
12199 }
12200 deserializer.deserialize_any(GeneratedVisitor)
12201 }
12202}
12203impl serde::Serialize for TableSchemaChange {
12204 #[allow(deprecated)]
12205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12206 where
12207 S: serde::Serializer,
12208 {
12209 use serde::ser::SerializeStruct;
12210 let mut len = 0;
12211 if self.change_type != 0 {
12212 len += 1;
12213 }
12214 if !self.cdc_table_id.is_empty() {
12215 len += 1;
12216 }
12217 if !self.columns.is_empty() {
12218 len += 1;
12219 }
12220 if !self.upstream_ddl.is_empty() {
12221 len += 1;
12222 }
12223 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
12224 if self.change_type != 0 {
12225 let v = table_schema_change::TableChangeType::try_from(self.change_type)
12226 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
12227 struct_ser.serialize_field("changeType", &v)?;
12228 }
12229 if !self.cdc_table_id.is_empty() {
12230 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
12231 }
12232 if !self.columns.is_empty() {
12233 struct_ser.serialize_field("columns", &self.columns)?;
12234 }
12235 if !self.upstream_ddl.is_empty() {
12236 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
12237 }
12238 struct_ser.end()
12239 }
12240}
12241impl<'de> serde::Deserialize<'de> for TableSchemaChange {
12242 #[allow(deprecated)]
12243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12244 where
12245 D: serde::Deserializer<'de>,
12246 {
12247 const FIELDS: &[&str] = &[
12248 "change_type",
12249 "changeType",
12250 "cdc_table_id",
12251 "cdcTableId",
12252 "columns",
12253 "upstream_ddl",
12254 "upstreamDdl",
12255 ];
12256
12257 #[allow(clippy::enum_variant_names)]
12258 enum GeneratedField {
12259 ChangeType,
12260 CdcTableId,
12261 Columns,
12262 UpstreamDdl,
12263 }
12264 impl<'de> serde::Deserialize<'de> for GeneratedField {
12265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12266 where
12267 D: serde::Deserializer<'de>,
12268 {
12269 struct GeneratedVisitor;
12270
12271 impl serde::de::Visitor<'_> for GeneratedVisitor {
12272 type Value = GeneratedField;
12273
12274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12275 write!(formatter, "expected one of: {:?}", &FIELDS)
12276 }
12277
12278 #[allow(unused_variables)]
12279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12280 where
12281 E: serde::de::Error,
12282 {
12283 match value {
12284 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
12285 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
12286 "columns" => Ok(GeneratedField::Columns),
12287 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
12288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12289 }
12290 }
12291 }
12292 deserializer.deserialize_identifier(GeneratedVisitor)
12293 }
12294 }
12295 struct GeneratedVisitor;
12296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12297 type Value = TableSchemaChange;
12298
12299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12300 formatter.write_str("struct ddl_service.TableSchemaChange")
12301 }
12302
12303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
12304 where
12305 V: serde::de::MapAccess<'de>,
12306 {
12307 let mut change_type__ = None;
12308 let mut cdc_table_id__ = None;
12309 let mut columns__ = None;
12310 let mut upstream_ddl__ = None;
12311 while let Some(k) = map_.next_key()? {
12312 match k {
12313 GeneratedField::ChangeType => {
12314 if change_type__.is_some() {
12315 return Err(serde::de::Error::duplicate_field("changeType"));
12316 }
12317 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
12318 }
12319 GeneratedField::CdcTableId => {
12320 if cdc_table_id__.is_some() {
12321 return Err(serde::de::Error::duplicate_field("cdcTableId"));
12322 }
12323 cdc_table_id__ = Some(map_.next_value()?);
12324 }
12325 GeneratedField::Columns => {
12326 if columns__.is_some() {
12327 return Err(serde::de::Error::duplicate_field("columns"));
12328 }
12329 columns__ = Some(map_.next_value()?);
12330 }
12331 GeneratedField::UpstreamDdl => {
12332 if upstream_ddl__.is_some() {
12333 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
12334 }
12335 upstream_ddl__ = Some(map_.next_value()?);
12336 }
12337 }
12338 }
12339 Ok(TableSchemaChange {
12340 change_type: change_type__.unwrap_or_default(),
12341 cdc_table_id: cdc_table_id__.unwrap_or_default(),
12342 columns: columns__.unwrap_or_default(),
12343 upstream_ddl: upstream_ddl__.unwrap_or_default(),
12344 })
12345 }
12346 }
12347 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
12348 }
12349}
12350impl serde::Serialize for table_schema_change::TableChangeType {
12351 #[allow(deprecated)]
12352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12353 where
12354 S: serde::Serializer,
12355 {
12356 let variant = match self {
12357 Self::Unspecified => "UNSPECIFIED",
12358 Self::Alter => "ALTER",
12359 Self::Create => "CREATE",
12360 Self::Drop => "DROP",
12361 };
12362 serializer.serialize_str(variant)
12363 }
12364}
12365impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
12366 #[allow(deprecated)]
12367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12368 where
12369 D: serde::Deserializer<'de>,
12370 {
12371 const FIELDS: &[&str] = &[
12372 "UNSPECIFIED",
12373 "ALTER",
12374 "CREATE",
12375 "DROP",
12376 ];
12377
12378 struct GeneratedVisitor;
12379
12380 impl serde::de::Visitor<'_> for GeneratedVisitor {
12381 type Value = table_schema_change::TableChangeType;
12382
12383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12384 write!(formatter, "expected one of: {:?}", &FIELDS)
12385 }
12386
12387 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12388 where
12389 E: serde::de::Error,
12390 {
12391 i32::try_from(v)
12392 .ok()
12393 .and_then(|x| x.try_into().ok())
12394 .ok_or_else(|| {
12395 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12396 })
12397 }
12398
12399 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12400 where
12401 E: serde::de::Error,
12402 {
12403 i32::try_from(v)
12404 .ok()
12405 .and_then(|x| x.try_into().ok())
12406 .ok_or_else(|| {
12407 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12408 })
12409 }
12410
12411 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12412 where
12413 E: serde::de::Error,
12414 {
12415 match value {
12416 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
12417 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
12418 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
12419 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
12420 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12421 }
12422 }
12423 }
12424 deserializer.deserialize_any(GeneratedVisitor)
12425 }
12426}
12427impl serde::Serialize for WaitRequest {
12428 #[allow(deprecated)]
12429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12430 where
12431 S: serde::Serializer,
12432 {
12433 use serde::ser::SerializeStruct;
12434 let len = 0;
12435 let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
12436 struct_ser.end()
12437 }
12438}
12439impl<'de> serde::Deserialize<'de> for WaitRequest {
12440 #[allow(deprecated)]
12441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12442 where
12443 D: serde::Deserializer<'de>,
12444 {
12445 const FIELDS: &[&str] = &[
12446 ];
12447
12448 #[allow(clippy::enum_variant_names)]
12449 enum GeneratedField {
12450 }
12451 impl<'de> serde::Deserialize<'de> for GeneratedField {
12452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12453 where
12454 D: serde::Deserializer<'de>,
12455 {
12456 struct GeneratedVisitor;
12457
12458 impl serde::de::Visitor<'_> for GeneratedVisitor {
12459 type Value = GeneratedField;
12460
12461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12462 write!(formatter, "expected one of: {:?}", &FIELDS)
12463 }
12464
12465 #[allow(unused_variables)]
12466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12467 where
12468 E: serde::de::Error,
12469 {
12470 Err(serde::de::Error::unknown_field(value, FIELDS))
12471 }
12472 }
12473 deserializer.deserialize_identifier(GeneratedVisitor)
12474 }
12475 }
12476 struct GeneratedVisitor;
12477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12478 type Value = WaitRequest;
12479
12480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12481 formatter.write_str("struct ddl_service.WaitRequest")
12482 }
12483
12484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
12485 where
12486 V: serde::de::MapAccess<'de>,
12487 {
12488 while map_.next_key::<GeneratedField>()?.is_some() {
12489 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12490 }
12491 Ok(WaitRequest {
12492 })
12493 }
12494 }
12495 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
12496 }
12497}
12498impl serde::Serialize for WaitResponse {
12499 #[allow(deprecated)]
12500 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12501 where
12502 S: serde::Serializer,
12503 {
12504 use serde::ser::SerializeStruct;
12505 let len = 0;
12506 let struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
12507 struct_ser.end()
12508 }
12509}
12510impl<'de> serde::Deserialize<'de> for WaitResponse {
12511 #[allow(deprecated)]
12512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12513 where
12514 D: serde::Deserializer<'de>,
12515 {
12516 const FIELDS: &[&str] = &[
12517 ];
12518
12519 #[allow(clippy::enum_variant_names)]
12520 enum GeneratedField {
12521 }
12522 impl<'de> serde::Deserialize<'de> for GeneratedField {
12523 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12524 where
12525 D: serde::Deserializer<'de>,
12526 {
12527 struct GeneratedVisitor;
12528
12529 impl serde::de::Visitor<'_> for GeneratedVisitor {
12530 type Value = GeneratedField;
12531
12532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12533 write!(formatter, "expected one of: {:?}", &FIELDS)
12534 }
12535
12536 #[allow(unused_variables)]
12537 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12538 where
12539 E: serde::de::Error,
12540 {
12541 Err(serde::de::Error::unknown_field(value, FIELDS))
12542 }
12543 }
12544 deserializer.deserialize_identifier(GeneratedVisitor)
12545 }
12546 }
12547 struct GeneratedVisitor;
12548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12549 type Value = WaitResponse;
12550
12551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12552 formatter.write_str("struct ddl_service.WaitResponse")
12553 }
12554
12555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
12556 where
12557 V: serde::de::MapAccess<'de>,
12558 {
12559 while map_.next_key::<GeneratedField>()?.is_some() {
12560 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12561 }
12562 Ok(WaitResponse {
12563 })
12564 }
12565 }
12566 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
12567 }
12568}
12569impl serde::Serialize for WaitVersion {
12570 #[allow(deprecated)]
12571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12572 where
12573 S: serde::Serializer,
12574 {
12575 use serde::ser::SerializeStruct;
12576 let mut len = 0;
12577 if self.catalog_version != 0 {
12578 len += 1;
12579 }
12580 if self.hummock_version_id != 0 {
12581 len += 1;
12582 }
12583 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
12584 if self.catalog_version != 0 {
12585 #[allow(clippy::needless_borrow)]
12586 #[allow(clippy::needless_borrows_for_generic_args)]
12587 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12588 }
12589 if self.hummock_version_id != 0 {
12590 #[allow(clippy::needless_borrow)]
12591 #[allow(clippy::needless_borrows_for_generic_args)]
12592 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
12593 }
12594 struct_ser.end()
12595 }
12596}
12597impl<'de> serde::Deserialize<'de> for WaitVersion {
12598 #[allow(deprecated)]
12599 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12600 where
12601 D: serde::Deserializer<'de>,
12602 {
12603 const FIELDS: &[&str] = &[
12604 "catalog_version",
12605 "catalogVersion",
12606 "hummock_version_id",
12607 "hummockVersionId",
12608 ];
12609
12610 #[allow(clippy::enum_variant_names)]
12611 enum GeneratedField {
12612 CatalogVersion,
12613 HummockVersionId,
12614 }
12615 impl<'de> serde::Deserialize<'de> for GeneratedField {
12616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12617 where
12618 D: serde::Deserializer<'de>,
12619 {
12620 struct GeneratedVisitor;
12621
12622 impl serde::de::Visitor<'_> for GeneratedVisitor {
12623 type Value = GeneratedField;
12624
12625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12626 write!(formatter, "expected one of: {:?}", &FIELDS)
12627 }
12628
12629 #[allow(unused_variables)]
12630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12631 where
12632 E: serde::de::Error,
12633 {
12634 match value {
12635 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12636 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
12637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12638 }
12639 }
12640 }
12641 deserializer.deserialize_identifier(GeneratedVisitor)
12642 }
12643 }
12644 struct GeneratedVisitor;
12645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12646 type Value = WaitVersion;
12647
12648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12649 formatter.write_str("struct ddl_service.WaitVersion")
12650 }
12651
12652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
12653 where
12654 V: serde::de::MapAccess<'de>,
12655 {
12656 let mut catalog_version__ = None;
12657 let mut hummock_version_id__ = None;
12658 while let Some(k) = map_.next_key()? {
12659 match k {
12660 GeneratedField::CatalogVersion => {
12661 if catalog_version__.is_some() {
12662 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12663 }
12664 catalog_version__ =
12665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12666 ;
12667 }
12668 GeneratedField::HummockVersionId => {
12669 if hummock_version_id__.is_some() {
12670 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
12671 }
12672 hummock_version_id__ =
12673 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12674 ;
12675 }
12676 }
12677 }
12678 Ok(WaitVersion {
12679 catalog_version: catalog_version__.unwrap_or_default(),
12680 hummock_version_id: hummock_version_id__.unwrap_or_default(),
12681 })
12682 }
12683 }
12684 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
12685 }
12686}