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 if self.cascade {
8693 len += 1;
8694 }
8695 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
8696 if self.secret_id != 0 {
8697 struct_ser.serialize_field("secretId", &self.secret_id)?;
8698 }
8699 if self.cascade {
8700 struct_ser.serialize_field("cascade", &self.cascade)?;
8701 }
8702 struct_ser.end()
8703 }
8704}
8705impl<'de> serde::Deserialize<'de> for DropSecretRequest {
8706 #[allow(deprecated)]
8707 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8708 where
8709 D: serde::Deserializer<'de>,
8710 {
8711 const FIELDS: &[&str] = &[
8712 "secret_id",
8713 "secretId",
8714 "cascade",
8715 ];
8716
8717 #[allow(clippy::enum_variant_names)]
8718 enum GeneratedField {
8719 SecretId,
8720 Cascade,
8721 }
8722 impl<'de> serde::Deserialize<'de> for GeneratedField {
8723 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8724 where
8725 D: serde::Deserializer<'de>,
8726 {
8727 struct GeneratedVisitor;
8728
8729 impl serde::de::Visitor<'_> for GeneratedVisitor {
8730 type Value = GeneratedField;
8731
8732 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8733 write!(formatter, "expected one of: {:?}", &FIELDS)
8734 }
8735
8736 #[allow(unused_variables)]
8737 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8738 where
8739 E: serde::de::Error,
8740 {
8741 match value {
8742 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
8743 "cascade" => Ok(GeneratedField::Cascade),
8744 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8745 }
8746 }
8747 }
8748 deserializer.deserialize_identifier(GeneratedVisitor)
8749 }
8750 }
8751 struct GeneratedVisitor;
8752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8753 type Value = DropSecretRequest;
8754
8755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8756 formatter.write_str("struct ddl_service.DropSecretRequest")
8757 }
8758
8759 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
8760 where
8761 V: serde::de::MapAccess<'de>,
8762 {
8763 let mut secret_id__ = None;
8764 let mut cascade__ = None;
8765 while let Some(k) = map_.next_key()? {
8766 match k {
8767 GeneratedField::SecretId => {
8768 if secret_id__.is_some() {
8769 return Err(serde::de::Error::duplicate_field("secretId"));
8770 }
8771 secret_id__ =
8772 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8773 ;
8774 }
8775 GeneratedField::Cascade => {
8776 if cascade__.is_some() {
8777 return Err(serde::de::Error::duplicate_field("cascade"));
8778 }
8779 cascade__ = Some(map_.next_value()?);
8780 }
8781 }
8782 }
8783 Ok(DropSecretRequest {
8784 secret_id: secret_id__.unwrap_or_default(),
8785 cascade: cascade__.unwrap_or_default(),
8786 })
8787 }
8788 }
8789 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
8790 }
8791}
8792impl serde::Serialize for DropSecretResponse {
8793 #[allow(deprecated)]
8794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8795 where
8796 S: serde::Serializer,
8797 {
8798 use serde::ser::SerializeStruct;
8799 let mut len = 0;
8800 if self.version.is_some() {
8801 len += 1;
8802 }
8803 if self.status.is_some() {
8804 len += 1;
8805 }
8806 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
8807 if let Some(v) = self.version.as_ref() {
8808 struct_ser.serialize_field("version", v)?;
8809 }
8810 if let Some(v) = self.status.as_ref() {
8811 struct_ser.serialize_field("status", v)?;
8812 }
8813 struct_ser.end()
8814 }
8815}
8816impl<'de> serde::Deserialize<'de> for DropSecretResponse {
8817 #[allow(deprecated)]
8818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8819 where
8820 D: serde::Deserializer<'de>,
8821 {
8822 const FIELDS: &[&str] = &[
8823 "version",
8824 "status",
8825 ];
8826
8827 #[allow(clippy::enum_variant_names)]
8828 enum GeneratedField {
8829 Version,
8830 Status,
8831 }
8832 impl<'de> serde::Deserialize<'de> for GeneratedField {
8833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8834 where
8835 D: serde::Deserializer<'de>,
8836 {
8837 struct GeneratedVisitor;
8838
8839 impl serde::de::Visitor<'_> for GeneratedVisitor {
8840 type Value = GeneratedField;
8841
8842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8843 write!(formatter, "expected one of: {:?}", &FIELDS)
8844 }
8845
8846 #[allow(unused_variables)]
8847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8848 where
8849 E: serde::de::Error,
8850 {
8851 match value {
8852 "version" => Ok(GeneratedField::Version),
8853 "status" => Ok(GeneratedField::Status),
8854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8855 }
8856 }
8857 }
8858 deserializer.deserialize_identifier(GeneratedVisitor)
8859 }
8860 }
8861 struct GeneratedVisitor;
8862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8863 type Value = DropSecretResponse;
8864
8865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8866 formatter.write_str("struct ddl_service.DropSecretResponse")
8867 }
8868
8869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
8870 where
8871 V: serde::de::MapAccess<'de>,
8872 {
8873 let mut version__ = None;
8874 let mut status__ = None;
8875 while let Some(k) = map_.next_key()? {
8876 match k {
8877 GeneratedField::Version => {
8878 if version__.is_some() {
8879 return Err(serde::de::Error::duplicate_field("version"));
8880 }
8881 version__ = map_.next_value()?;
8882 }
8883 GeneratedField::Status => {
8884 if status__.is_some() {
8885 return Err(serde::de::Error::duplicate_field("status"));
8886 }
8887 status__ = map_.next_value()?;
8888 }
8889 }
8890 }
8891 Ok(DropSecretResponse {
8892 version: version__,
8893 status: status__,
8894 })
8895 }
8896 }
8897 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
8898 }
8899}
8900impl serde::Serialize for DropSinkRequest {
8901 #[allow(deprecated)]
8902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8903 where
8904 S: serde::Serializer,
8905 {
8906 use serde::ser::SerializeStruct;
8907 let mut len = 0;
8908 if self.sink_id != 0 {
8909 len += 1;
8910 }
8911 if self.cascade {
8912 len += 1;
8913 }
8914 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
8915 if self.sink_id != 0 {
8916 struct_ser.serialize_field("sinkId", &self.sink_id)?;
8917 }
8918 if self.cascade {
8919 struct_ser.serialize_field("cascade", &self.cascade)?;
8920 }
8921 struct_ser.end()
8922 }
8923}
8924impl<'de> serde::Deserialize<'de> for DropSinkRequest {
8925 #[allow(deprecated)]
8926 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8927 where
8928 D: serde::Deserializer<'de>,
8929 {
8930 const FIELDS: &[&str] = &[
8931 "sink_id",
8932 "sinkId",
8933 "cascade",
8934 ];
8935
8936 #[allow(clippy::enum_variant_names)]
8937 enum GeneratedField {
8938 SinkId,
8939 Cascade,
8940 }
8941 impl<'de> serde::Deserialize<'de> for GeneratedField {
8942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8943 where
8944 D: serde::Deserializer<'de>,
8945 {
8946 struct GeneratedVisitor;
8947
8948 impl serde::de::Visitor<'_> for GeneratedVisitor {
8949 type Value = GeneratedField;
8950
8951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8952 write!(formatter, "expected one of: {:?}", &FIELDS)
8953 }
8954
8955 #[allow(unused_variables)]
8956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8957 where
8958 E: serde::de::Error,
8959 {
8960 match value {
8961 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
8962 "cascade" => Ok(GeneratedField::Cascade),
8963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8964 }
8965 }
8966 }
8967 deserializer.deserialize_identifier(GeneratedVisitor)
8968 }
8969 }
8970 struct GeneratedVisitor;
8971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8972 type Value = DropSinkRequest;
8973
8974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8975 formatter.write_str("struct ddl_service.DropSinkRequest")
8976 }
8977
8978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
8979 where
8980 V: serde::de::MapAccess<'de>,
8981 {
8982 let mut sink_id__ = None;
8983 let mut cascade__ = None;
8984 while let Some(k) = map_.next_key()? {
8985 match k {
8986 GeneratedField::SinkId => {
8987 if sink_id__.is_some() {
8988 return Err(serde::de::Error::duplicate_field("sinkId"));
8989 }
8990 sink_id__ =
8991 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8992 ;
8993 }
8994 GeneratedField::Cascade => {
8995 if cascade__.is_some() {
8996 return Err(serde::de::Error::duplicate_field("cascade"));
8997 }
8998 cascade__ = Some(map_.next_value()?);
8999 }
9000 }
9001 }
9002 Ok(DropSinkRequest {
9003 sink_id: sink_id__.unwrap_or_default(),
9004 cascade: cascade__.unwrap_or_default(),
9005 })
9006 }
9007 }
9008 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
9009 }
9010}
9011impl serde::Serialize for DropSinkResponse {
9012 #[allow(deprecated)]
9013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9014 where
9015 S: serde::Serializer,
9016 {
9017 use serde::ser::SerializeStruct;
9018 let mut len = 0;
9019 if self.status.is_some() {
9020 len += 1;
9021 }
9022 if self.version.is_some() {
9023 len += 1;
9024 }
9025 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
9026 if let Some(v) = self.status.as_ref() {
9027 struct_ser.serialize_field("status", v)?;
9028 }
9029 if let Some(v) = self.version.as_ref() {
9030 struct_ser.serialize_field("version", v)?;
9031 }
9032 struct_ser.end()
9033 }
9034}
9035impl<'de> serde::Deserialize<'de> for DropSinkResponse {
9036 #[allow(deprecated)]
9037 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9038 where
9039 D: serde::Deserializer<'de>,
9040 {
9041 const FIELDS: &[&str] = &[
9042 "status",
9043 "version",
9044 ];
9045
9046 #[allow(clippy::enum_variant_names)]
9047 enum GeneratedField {
9048 Status,
9049 Version,
9050 }
9051 impl<'de> serde::Deserialize<'de> for GeneratedField {
9052 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9053 where
9054 D: serde::Deserializer<'de>,
9055 {
9056 struct GeneratedVisitor;
9057
9058 impl serde::de::Visitor<'_> for GeneratedVisitor {
9059 type Value = GeneratedField;
9060
9061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9062 write!(formatter, "expected one of: {:?}", &FIELDS)
9063 }
9064
9065 #[allow(unused_variables)]
9066 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9067 where
9068 E: serde::de::Error,
9069 {
9070 match value {
9071 "status" => Ok(GeneratedField::Status),
9072 "version" => Ok(GeneratedField::Version),
9073 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9074 }
9075 }
9076 }
9077 deserializer.deserialize_identifier(GeneratedVisitor)
9078 }
9079 }
9080 struct GeneratedVisitor;
9081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9082 type Value = DropSinkResponse;
9083
9084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9085 formatter.write_str("struct ddl_service.DropSinkResponse")
9086 }
9087
9088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
9089 where
9090 V: serde::de::MapAccess<'de>,
9091 {
9092 let mut status__ = None;
9093 let mut version__ = None;
9094 while let Some(k) = map_.next_key()? {
9095 match k {
9096 GeneratedField::Status => {
9097 if status__.is_some() {
9098 return Err(serde::de::Error::duplicate_field("status"));
9099 }
9100 status__ = map_.next_value()?;
9101 }
9102 GeneratedField::Version => {
9103 if version__.is_some() {
9104 return Err(serde::de::Error::duplicate_field("version"));
9105 }
9106 version__ = map_.next_value()?;
9107 }
9108 }
9109 }
9110 Ok(DropSinkResponse {
9111 status: status__,
9112 version: version__,
9113 })
9114 }
9115 }
9116 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9117 }
9118}
9119impl serde::Serialize for DropSourceRequest {
9120 #[allow(deprecated)]
9121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9122 where
9123 S: serde::Serializer,
9124 {
9125 use serde::ser::SerializeStruct;
9126 let mut len = 0;
9127 if self.source_id != 0 {
9128 len += 1;
9129 }
9130 if self.cascade {
9131 len += 1;
9132 }
9133 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9134 if self.source_id != 0 {
9135 struct_ser.serialize_field("sourceId", &self.source_id)?;
9136 }
9137 if self.cascade {
9138 struct_ser.serialize_field("cascade", &self.cascade)?;
9139 }
9140 struct_ser.end()
9141 }
9142}
9143impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9144 #[allow(deprecated)]
9145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9146 where
9147 D: serde::Deserializer<'de>,
9148 {
9149 const FIELDS: &[&str] = &[
9150 "source_id",
9151 "sourceId",
9152 "cascade",
9153 ];
9154
9155 #[allow(clippy::enum_variant_names)]
9156 enum GeneratedField {
9157 SourceId,
9158 Cascade,
9159 }
9160 impl<'de> serde::Deserialize<'de> for GeneratedField {
9161 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9162 where
9163 D: serde::Deserializer<'de>,
9164 {
9165 struct GeneratedVisitor;
9166
9167 impl serde::de::Visitor<'_> for GeneratedVisitor {
9168 type Value = GeneratedField;
9169
9170 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9171 write!(formatter, "expected one of: {:?}", &FIELDS)
9172 }
9173
9174 #[allow(unused_variables)]
9175 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9176 where
9177 E: serde::de::Error,
9178 {
9179 match value {
9180 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9181 "cascade" => Ok(GeneratedField::Cascade),
9182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9183 }
9184 }
9185 }
9186 deserializer.deserialize_identifier(GeneratedVisitor)
9187 }
9188 }
9189 struct GeneratedVisitor;
9190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9191 type Value = DropSourceRequest;
9192
9193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9194 formatter.write_str("struct ddl_service.DropSourceRequest")
9195 }
9196
9197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9198 where
9199 V: serde::de::MapAccess<'de>,
9200 {
9201 let mut source_id__ = None;
9202 let mut cascade__ = None;
9203 while let Some(k) = map_.next_key()? {
9204 match k {
9205 GeneratedField::SourceId => {
9206 if source_id__.is_some() {
9207 return Err(serde::de::Error::duplicate_field("sourceId"));
9208 }
9209 source_id__ =
9210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9211 ;
9212 }
9213 GeneratedField::Cascade => {
9214 if cascade__.is_some() {
9215 return Err(serde::de::Error::duplicate_field("cascade"));
9216 }
9217 cascade__ = Some(map_.next_value()?);
9218 }
9219 }
9220 }
9221 Ok(DropSourceRequest {
9222 source_id: source_id__.unwrap_or_default(),
9223 cascade: cascade__.unwrap_or_default(),
9224 })
9225 }
9226 }
9227 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
9228 }
9229}
9230impl serde::Serialize for DropSourceResponse {
9231 #[allow(deprecated)]
9232 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9233 where
9234 S: serde::Serializer,
9235 {
9236 use serde::ser::SerializeStruct;
9237 let mut len = 0;
9238 if self.status.is_some() {
9239 len += 1;
9240 }
9241 if self.version.is_some() {
9242 len += 1;
9243 }
9244 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
9245 if let Some(v) = self.status.as_ref() {
9246 struct_ser.serialize_field("status", v)?;
9247 }
9248 if let Some(v) = self.version.as_ref() {
9249 struct_ser.serialize_field("version", v)?;
9250 }
9251 struct_ser.end()
9252 }
9253}
9254impl<'de> serde::Deserialize<'de> for DropSourceResponse {
9255 #[allow(deprecated)]
9256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9257 where
9258 D: serde::Deserializer<'de>,
9259 {
9260 const FIELDS: &[&str] = &[
9261 "status",
9262 "version",
9263 ];
9264
9265 #[allow(clippy::enum_variant_names)]
9266 enum GeneratedField {
9267 Status,
9268 Version,
9269 }
9270 impl<'de> serde::Deserialize<'de> for GeneratedField {
9271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9272 where
9273 D: serde::Deserializer<'de>,
9274 {
9275 struct GeneratedVisitor;
9276
9277 impl serde::de::Visitor<'_> for GeneratedVisitor {
9278 type Value = GeneratedField;
9279
9280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9281 write!(formatter, "expected one of: {:?}", &FIELDS)
9282 }
9283
9284 #[allow(unused_variables)]
9285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9286 where
9287 E: serde::de::Error,
9288 {
9289 match value {
9290 "status" => Ok(GeneratedField::Status),
9291 "version" => Ok(GeneratedField::Version),
9292 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9293 }
9294 }
9295 }
9296 deserializer.deserialize_identifier(GeneratedVisitor)
9297 }
9298 }
9299 struct GeneratedVisitor;
9300 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9301 type Value = DropSourceResponse;
9302
9303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9304 formatter.write_str("struct ddl_service.DropSourceResponse")
9305 }
9306
9307 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9308 where
9309 V: serde::de::MapAccess<'de>,
9310 {
9311 let mut status__ = None;
9312 let mut version__ = None;
9313 while let Some(k) = map_.next_key()? {
9314 match k {
9315 GeneratedField::Status => {
9316 if status__.is_some() {
9317 return Err(serde::de::Error::duplicate_field("status"));
9318 }
9319 status__ = map_.next_value()?;
9320 }
9321 GeneratedField::Version => {
9322 if version__.is_some() {
9323 return Err(serde::de::Error::duplicate_field("version"));
9324 }
9325 version__ = map_.next_value()?;
9326 }
9327 }
9328 }
9329 Ok(DropSourceResponse {
9330 status: status__,
9331 version: version__,
9332 })
9333 }
9334 }
9335 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9336 }
9337}
9338impl serde::Serialize for DropSubscriptionRequest {
9339 #[allow(deprecated)]
9340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9341 where
9342 S: serde::Serializer,
9343 {
9344 use serde::ser::SerializeStruct;
9345 let mut len = 0;
9346 if self.subscription_id != 0 {
9347 len += 1;
9348 }
9349 if self.cascade {
9350 len += 1;
9351 }
9352 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9353 if self.subscription_id != 0 {
9354 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9355 }
9356 if self.cascade {
9357 struct_ser.serialize_field("cascade", &self.cascade)?;
9358 }
9359 struct_ser.end()
9360 }
9361}
9362impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9363 #[allow(deprecated)]
9364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9365 where
9366 D: serde::Deserializer<'de>,
9367 {
9368 const FIELDS: &[&str] = &[
9369 "subscription_id",
9370 "subscriptionId",
9371 "cascade",
9372 ];
9373
9374 #[allow(clippy::enum_variant_names)]
9375 enum GeneratedField {
9376 SubscriptionId,
9377 Cascade,
9378 }
9379 impl<'de> serde::Deserialize<'de> for GeneratedField {
9380 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9381 where
9382 D: serde::Deserializer<'de>,
9383 {
9384 struct GeneratedVisitor;
9385
9386 impl serde::de::Visitor<'_> for GeneratedVisitor {
9387 type Value = GeneratedField;
9388
9389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9390 write!(formatter, "expected one of: {:?}", &FIELDS)
9391 }
9392
9393 #[allow(unused_variables)]
9394 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9395 where
9396 E: serde::de::Error,
9397 {
9398 match value {
9399 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9400 "cascade" => Ok(GeneratedField::Cascade),
9401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9402 }
9403 }
9404 }
9405 deserializer.deserialize_identifier(GeneratedVisitor)
9406 }
9407 }
9408 struct GeneratedVisitor;
9409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9410 type Value = DropSubscriptionRequest;
9411
9412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9413 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9414 }
9415
9416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9417 where
9418 V: serde::de::MapAccess<'de>,
9419 {
9420 let mut subscription_id__ = None;
9421 let mut cascade__ = None;
9422 while let Some(k) = map_.next_key()? {
9423 match k {
9424 GeneratedField::SubscriptionId => {
9425 if subscription_id__.is_some() {
9426 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9427 }
9428 subscription_id__ =
9429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9430 ;
9431 }
9432 GeneratedField::Cascade => {
9433 if cascade__.is_some() {
9434 return Err(serde::de::Error::duplicate_field("cascade"));
9435 }
9436 cascade__ = Some(map_.next_value()?);
9437 }
9438 }
9439 }
9440 Ok(DropSubscriptionRequest {
9441 subscription_id: subscription_id__.unwrap_or_default(),
9442 cascade: cascade__.unwrap_or_default(),
9443 })
9444 }
9445 }
9446 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9447 }
9448}
9449impl serde::Serialize for DropSubscriptionResponse {
9450 #[allow(deprecated)]
9451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9452 where
9453 S: serde::Serializer,
9454 {
9455 use serde::ser::SerializeStruct;
9456 let mut len = 0;
9457 if self.status.is_some() {
9458 len += 1;
9459 }
9460 if self.version.is_some() {
9461 len += 1;
9462 }
9463 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9464 if let Some(v) = self.status.as_ref() {
9465 struct_ser.serialize_field("status", v)?;
9466 }
9467 if let Some(v) = self.version.as_ref() {
9468 struct_ser.serialize_field("version", v)?;
9469 }
9470 struct_ser.end()
9471 }
9472}
9473impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9474 #[allow(deprecated)]
9475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9476 where
9477 D: serde::Deserializer<'de>,
9478 {
9479 const FIELDS: &[&str] = &[
9480 "status",
9481 "version",
9482 ];
9483
9484 #[allow(clippy::enum_variant_names)]
9485 enum GeneratedField {
9486 Status,
9487 Version,
9488 }
9489 impl<'de> serde::Deserialize<'de> for GeneratedField {
9490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9491 where
9492 D: serde::Deserializer<'de>,
9493 {
9494 struct GeneratedVisitor;
9495
9496 impl serde::de::Visitor<'_> for GeneratedVisitor {
9497 type Value = GeneratedField;
9498
9499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9500 write!(formatter, "expected one of: {:?}", &FIELDS)
9501 }
9502
9503 #[allow(unused_variables)]
9504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9505 where
9506 E: serde::de::Error,
9507 {
9508 match value {
9509 "status" => Ok(GeneratedField::Status),
9510 "version" => Ok(GeneratedField::Version),
9511 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9512 }
9513 }
9514 }
9515 deserializer.deserialize_identifier(GeneratedVisitor)
9516 }
9517 }
9518 struct GeneratedVisitor;
9519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9520 type Value = DropSubscriptionResponse;
9521
9522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9523 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
9524 }
9525
9526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
9527 where
9528 V: serde::de::MapAccess<'de>,
9529 {
9530 let mut status__ = None;
9531 let mut version__ = None;
9532 while let Some(k) = map_.next_key()? {
9533 match k {
9534 GeneratedField::Status => {
9535 if status__.is_some() {
9536 return Err(serde::de::Error::duplicate_field("status"));
9537 }
9538 status__ = map_.next_value()?;
9539 }
9540 GeneratedField::Version => {
9541 if version__.is_some() {
9542 return Err(serde::de::Error::duplicate_field("version"));
9543 }
9544 version__ = map_.next_value()?;
9545 }
9546 }
9547 }
9548 Ok(DropSubscriptionResponse {
9549 status: status__,
9550 version: version__,
9551 })
9552 }
9553 }
9554 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
9555 }
9556}
9557impl serde::Serialize for DropTableRequest {
9558 #[allow(deprecated)]
9559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9560 where
9561 S: serde::Serializer,
9562 {
9563 use serde::ser::SerializeStruct;
9564 let mut len = 0;
9565 if self.table_id != 0 {
9566 len += 1;
9567 }
9568 if self.cascade {
9569 len += 1;
9570 }
9571 if self.source_id.is_some() {
9572 len += 1;
9573 }
9574 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
9575 if self.table_id != 0 {
9576 struct_ser.serialize_field("tableId", &self.table_id)?;
9577 }
9578 if self.cascade {
9579 struct_ser.serialize_field("cascade", &self.cascade)?;
9580 }
9581 if let Some(v) = self.source_id.as_ref() {
9582 match v {
9583 drop_table_request::SourceId::Id(v) => {
9584 struct_ser.serialize_field("id", v)?;
9585 }
9586 }
9587 }
9588 struct_ser.end()
9589 }
9590}
9591impl<'de> serde::Deserialize<'de> for DropTableRequest {
9592 #[allow(deprecated)]
9593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9594 where
9595 D: serde::Deserializer<'de>,
9596 {
9597 const FIELDS: &[&str] = &[
9598 "table_id",
9599 "tableId",
9600 "cascade",
9601 "id",
9602 ];
9603
9604 #[allow(clippy::enum_variant_names)]
9605 enum GeneratedField {
9606 TableId,
9607 Cascade,
9608 Id,
9609 }
9610 impl<'de> serde::Deserialize<'de> for GeneratedField {
9611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9612 where
9613 D: serde::Deserializer<'de>,
9614 {
9615 struct GeneratedVisitor;
9616
9617 impl serde::de::Visitor<'_> for GeneratedVisitor {
9618 type Value = GeneratedField;
9619
9620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9621 write!(formatter, "expected one of: {:?}", &FIELDS)
9622 }
9623
9624 #[allow(unused_variables)]
9625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9626 where
9627 E: serde::de::Error,
9628 {
9629 match value {
9630 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9631 "cascade" => Ok(GeneratedField::Cascade),
9632 "id" => Ok(GeneratedField::Id),
9633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9634 }
9635 }
9636 }
9637 deserializer.deserialize_identifier(GeneratedVisitor)
9638 }
9639 }
9640 struct GeneratedVisitor;
9641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9642 type Value = DropTableRequest;
9643
9644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9645 formatter.write_str("struct ddl_service.DropTableRequest")
9646 }
9647
9648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
9649 where
9650 V: serde::de::MapAccess<'de>,
9651 {
9652 let mut table_id__ = None;
9653 let mut cascade__ = None;
9654 let mut source_id__ = None;
9655 while let Some(k) = map_.next_key()? {
9656 match k {
9657 GeneratedField::TableId => {
9658 if table_id__.is_some() {
9659 return Err(serde::de::Error::duplicate_field("tableId"));
9660 }
9661 table_id__ =
9662 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9663 ;
9664 }
9665 GeneratedField::Cascade => {
9666 if cascade__.is_some() {
9667 return Err(serde::de::Error::duplicate_field("cascade"));
9668 }
9669 cascade__ = Some(map_.next_value()?);
9670 }
9671 GeneratedField::Id => {
9672 if source_id__.is_some() {
9673 return Err(serde::de::Error::duplicate_field("id"));
9674 }
9675 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
9676 }
9677 }
9678 }
9679 Ok(DropTableRequest {
9680 table_id: table_id__.unwrap_or_default(),
9681 cascade: cascade__.unwrap_or_default(),
9682 source_id: source_id__,
9683 })
9684 }
9685 }
9686 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
9687 }
9688}
9689impl serde::Serialize for DropTableResponse {
9690 #[allow(deprecated)]
9691 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9692 where
9693 S: serde::Serializer,
9694 {
9695 use serde::ser::SerializeStruct;
9696 let mut len = 0;
9697 if self.status.is_some() {
9698 len += 1;
9699 }
9700 if self.version.is_some() {
9701 len += 1;
9702 }
9703 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
9704 if let Some(v) = self.status.as_ref() {
9705 struct_ser.serialize_field("status", v)?;
9706 }
9707 if let Some(v) = self.version.as_ref() {
9708 struct_ser.serialize_field("version", v)?;
9709 }
9710 struct_ser.end()
9711 }
9712}
9713impl<'de> serde::Deserialize<'de> for DropTableResponse {
9714 #[allow(deprecated)]
9715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9716 where
9717 D: serde::Deserializer<'de>,
9718 {
9719 const FIELDS: &[&str] = &[
9720 "status",
9721 "version",
9722 ];
9723
9724 #[allow(clippy::enum_variant_names)]
9725 enum GeneratedField {
9726 Status,
9727 Version,
9728 }
9729 impl<'de> serde::Deserialize<'de> for GeneratedField {
9730 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9731 where
9732 D: serde::Deserializer<'de>,
9733 {
9734 struct GeneratedVisitor;
9735
9736 impl serde::de::Visitor<'_> for GeneratedVisitor {
9737 type Value = GeneratedField;
9738
9739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9740 write!(formatter, "expected one of: {:?}", &FIELDS)
9741 }
9742
9743 #[allow(unused_variables)]
9744 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9745 where
9746 E: serde::de::Error,
9747 {
9748 match value {
9749 "status" => Ok(GeneratedField::Status),
9750 "version" => Ok(GeneratedField::Version),
9751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9752 }
9753 }
9754 }
9755 deserializer.deserialize_identifier(GeneratedVisitor)
9756 }
9757 }
9758 struct GeneratedVisitor;
9759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9760 type Value = DropTableResponse;
9761
9762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9763 formatter.write_str("struct ddl_service.DropTableResponse")
9764 }
9765
9766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
9767 where
9768 V: serde::de::MapAccess<'de>,
9769 {
9770 let mut status__ = None;
9771 let mut version__ = None;
9772 while let Some(k) = map_.next_key()? {
9773 match k {
9774 GeneratedField::Status => {
9775 if status__.is_some() {
9776 return Err(serde::de::Error::duplicate_field("status"));
9777 }
9778 status__ = map_.next_value()?;
9779 }
9780 GeneratedField::Version => {
9781 if version__.is_some() {
9782 return Err(serde::de::Error::duplicate_field("version"));
9783 }
9784 version__ = map_.next_value()?;
9785 }
9786 }
9787 }
9788 Ok(DropTableResponse {
9789 status: status__,
9790 version: version__,
9791 })
9792 }
9793 }
9794 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
9795 }
9796}
9797impl serde::Serialize for DropViewRequest {
9798 #[allow(deprecated)]
9799 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9800 where
9801 S: serde::Serializer,
9802 {
9803 use serde::ser::SerializeStruct;
9804 let mut len = 0;
9805 if self.view_id != 0 {
9806 len += 1;
9807 }
9808 if self.cascade {
9809 len += 1;
9810 }
9811 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
9812 if self.view_id != 0 {
9813 struct_ser.serialize_field("viewId", &self.view_id)?;
9814 }
9815 if self.cascade {
9816 struct_ser.serialize_field("cascade", &self.cascade)?;
9817 }
9818 struct_ser.end()
9819 }
9820}
9821impl<'de> serde::Deserialize<'de> for DropViewRequest {
9822 #[allow(deprecated)]
9823 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9824 where
9825 D: serde::Deserializer<'de>,
9826 {
9827 const FIELDS: &[&str] = &[
9828 "view_id",
9829 "viewId",
9830 "cascade",
9831 ];
9832
9833 #[allow(clippy::enum_variant_names)]
9834 enum GeneratedField {
9835 ViewId,
9836 Cascade,
9837 }
9838 impl<'de> serde::Deserialize<'de> for GeneratedField {
9839 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9840 where
9841 D: serde::Deserializer<'de>,
9842 {
9843 struct GeneratedVisitor;
9844
9845 impl serde::de::Visitor<'_> for GeneratedVisitor {
9846 type Value = GeneratedField;
9847
9848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9849 write!(formatter, "expected one of: {:?}", &FIELDS)
9850 }
9851
9852 #[allow(unused_variables)]
9853 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9854 where
9855 E: serde::de::Error,
9856 {
9857 match value {
9858 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
9859 "cascade" => Ok(GeneratedField::Cascade),
9860 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9861 }
9862 }
9863 }
9864 deserializer.deserialize_identifier(GeneratedVisitor)
9865 }
9866 }
9867 struct GeneratedVisitor;
9868 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9869 type Value = DropViewRequest;
9870
9871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9872 formatter.write_str("struct ddl_service.DropViewRequest")
9873 }
9874
9875 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
9876 where
9877 V: serde::de::MapAccess<'de>,
9878 {
9879 let mut view_id__ = None;
9880 let mut cascade__ = None;
9881 while let Some(k) = map_.next_key()? {
9882 match k {
9883 GeneratedField::ViewId => {
9884 if view_id__.is_some() {
9885 return Err(serde::de::Error::duplicate_field("viewId"));
9886 }
9887 view_id__ =
9888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9889 ;
9890 }
9891 GeneratedField::Cascade => {
9892 if cascade__.is_some() {
9893 return Err(serde::de::Error::duplicate_field("cascade"));
9894 }
9895 cascade__ = Some(map_.next_value()?);
9896 }
9897 }
9898 }
9899 Ok(DropViewRequest {
9900 view_id: view_id__.unwrap_or_default(),
9901 cascade: cascade__.unwrap_or_default(),
9902 })
9903 }
9904 }
9905 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
9906 }
9907}
9908impl serde::Serialize for DropViewResponse {
9909 #[allow(deprecated)]
9910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9911 where
9912 S: serde::Serializer,
9913 {
9914 use serde::ser::SerializeStruct;
9915 let mut len = 0;
9916 if self.status.is_some() {
9917 len += 1;
9918 }
9919 if self.version.is_some() {
9920 len += 1;
9921 }
9922 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
9923 if let Some(v) = self.status.as_ref() {
9924 struct_ser.serialize_field("status", v)?;
9925 }
9926 if let Some(v) = self.version.as_ref() {
9927 struct_ser.serialize_field("version", v)?;
9928 }
9929 struct_ser.end()
9930 }
9931}
9932impl<'de> serde::Deserialize<'de> for DropViewResponse {
9933 #[allow(deprecated)]
9934 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9935 where
9936 D: serde::Deserializer<'de>,
9937 {
9938 const FIELDS: &[&str] = &[
9939 "status",
9940 "version",
9941 ];
9942
9943 #[allow(clippy::enum_variant_names)]
9944 enum GeneratedField {
9945 Status,
9946 Version,
9947 }
9948 impl<'de> serde::Deserialize<'de> for GeneratedField {
9949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9950 where
9951 D: serde::Deserializer<'de>,
9952 {
9953 struct GeneratedVisitor;
9954
9955 impl serde::de::Visitor<'_> for GeneratedVisitor {
9956 type Value = GeneratedField;
9957
9958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9959 write!(formatter, "expected one of: {:?}", &FIELDS)
9960 }
9961
9962 #[allow(unused_variables)]
9963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9964 where
9965 E: serde::de::Error,
9966 {
9967 match value {
9968 "status" => Ok(GeneratedField::Status),
9969 "version" => Ok(GeneratedField::Version),
9970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9971 }
9972 }
9973 }
9974 deserializer.deserialize_identifier(GeneratedVisitor)
9975 }
9976 }
9977 struct GeneratedVisitor;
9978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9979 type Value = DropViewResponse;
9980
9981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9982 formatter.write_str("struct ddl_service.DropViewResponse")
9983 }
9984
9985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
9986 where
9987 V: serde::de::MapAccess<'de>,
9988 {
9989 let mut status__ = None;
9990 let mut version__ = None;
9991 while let Some(k) = map_.next_key()? {
9992 match k {
9993 GeneratedField::Status => {
9994 if status__.is_some() {
9995 return Err(serde::de::Error::duplicate_field("status"));
9996 }
9997 status__ = map_.next_value()?;
9998 }
9999 GeneratedField::Version => {
10000 if version__.is_some() {
10001 return Err(serde::de::Error::duplicate_field("version"));
10002 }
10003 version__ = map_.next_value()?;
10004 }
10005 }
10006 }
10007 Ok(DropViewResponse {
10008 status: status__,
10009 version: version__,
10010 })
10011 }
10012 }
10013 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
10014 }
10015}
10016impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
10017 #[allow(deprecated)]
10018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10019 where
10020 S: serde::Serializer,
10021 {
10022 use serde::ser::SerializeStruct;
10023 let mut len = 0;
10024 if self.sink_id != 0 {
10025 len += 1;
10026 }
10027 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
10028 if self.sink_id != 0 {
10029 struct_ser.serialize_field("sinkId", &self.sink_id)?;
10030 }
10031 struct_ser.end()
10032 }
10033}
10034impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
10035 #[allow(deprecated)]
10036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10037 where
10038 D: serde::Deserializer<'de>,
10039 {
10040 const FIELDS: &[&str] = &[
10041 "sink_id",
10042 "sinkId",
10043 ];
10044
10045 #[allow(clippy::enum_variant_names)]
10046 enum GeneratedField {
10047 SinkId,
10048 }
10049 impl<'de> serde::Deserialize<'de> for GeneratedField {
10050 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10051 where
10052 D: serde::Deserializer<'de>,
10053 {
10054 struct GeneratedVisitor;
10055
10056 impl serde::de::Visitor<'_> for GeneratedVisitor {
10057 type Value = GeneratedField;
10058
10059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10060 write!(formatter, "expected one of: {:?}", &FIELDS)
10061 }
10062
10063 #[allow(unused_variables)]
10064 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10065 where
10066 E: serde::de::Error,
10067 {
10068 match value {
10069 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
10070 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10071 }
10072 }
10073 }
10074 deserializer.deserialize_identifier(GeneratedVisitor)
10075 }
10076 }
10077 struct GeneratedVisitor;
10078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10079 type Value = ExpireIcebergTableSnapshotsRequest;
10080
10081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10082 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
10083 }
10084
10085 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
10086 where
10087 V: serde::de::MapAccess<'de>,
10088 {
10089 let mut sink_id__ = None;
10090 while let Some(k) = map_.next_key()? {
10091 match k {
10092 GeneratedField::SinkId => {
10093 if sink_id__.is_some() {
10094 return Err(serde::de::Error::duplicate_field("sinkId"));
10095 }
10096 sink_id__ =
10097 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10098 ;
10099 }
10100 }
10101 }
10102 Ok(ExpireIcebergTableSnapshotsRequest {
10103 sink_id: sink_id__.unwrap_or_default(),
10104 })
10105 }
10106 }
10107 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10108 }
10109}
10110impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10111 #[allow(deprecated)]
10112 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10113 where
10114 S: serde::Serializer,
10115 {
10116 use serde::ser::SerializeStruct;
10117 let mut len = 0;
10118 if self.status.is_some() {
10119 len += 1;
10120 }
10121 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10122 if let Some(v) = self.status.as_ref() {
10123 struct_ser.serialize_field("status", v)?;
10124 }
10125 struct_ser.end()
10126 }
10127}
10128impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10129 #[allow(deprecated)]
10130 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10131 where
10132 D: serde::Deserializer<'de>,
10133 {
10134 const FIELDS: &[&str] = &[
10135 "status",
10136 ];
10137
10138 #[allow(clippy::enum_variant_names)]
10139 enum GeneratedField {
10140 Status,
10141 }
10142 impl<'de> serde::Deserialize<'de> for GeneratedField {
10143 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10144 where
10145 D: serde::Deserializer<'de>,
10146 {
10147 struct GeneratedVisitor;
10148
10149 impl serde::de::Visitor<'_> for GeneratedVisitor {
10150 type Value = GeneratedField;
10151
10152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10153 write!(formatter, "expected one of: {:?}", &FIELDS)
10154 }
10155
10156 #[allow(unused_variables)]
10157 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10158 where
10159 E: serde::de::Error,
10160 {
10161 match value {
10162 "status" => Ok(GeneratedField::Status),
10163 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10164 }
10165 }
10166 }
10167 deserializer.deserialize_identifier(GeneratedVisitor)
10168 }
10169 }
10170 struct GeneratedVisitor;
10171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10172 type Value = ExpireIcebergTableSnapshotsResponse;
10173
10174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10175 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10176 }
10177
10178 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10179 where
10180 V: serde::de::MapAccess<'de>,
10181 {
10182 let mut status__ = None;
10183 while let Some(k) = map_.next_key()? {
10184 match k {
10185 GeneratedField::Status => {
10186 if status__.is_some() {
10187 return Err(serde::de::Error::duplicate_field("status"));
10188 }
10189 status__ = map_.next_value()?;
10190 }
10191 }
10192 }
10193 Ok(ExpireIcebergTableSnapshotsResponse {
10194 status: status__,
10195 })
10196 }
10197 }
10198 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10199 }
10200}
10201impl serde::Serialize for GetDdlProgressRequest {
10202 #[allow(deprecated)]
10203 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10204 where
10205 S: serde::Serializer,
10206 {
10207 use serde::ser::SerializeStruct;
10208 let len = 0;
10209 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10210 struct_ser.end()
10211 }
10212}
10213impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10214 #[allow(deprecated)]
10215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10216 where
10217 D: serde::Deserializer<'de>,
10218 {
10219 const FIELDS: &[&str] = &[
10220 ];
10221
10222 #[allow(clippy::enum_variant_names)]
10223 enum GeneratedField {
10224 }
10225 impl<'de> serde::Deserialize<'de> for GeneratedField {
10226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10227 where
10228 D: serde::Deserializer<'de>,
10229 {
10230 struct GeneratedVisitor;
10231
10232 impl serde::de::Visitor<'_> for GeneratedVisitor {
10233 type Value = GeneratedField;
10234
10235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10236 write!(formatter, "expected one of: {:?}", &FIELDS)
10237 }
10238
10239 #[allow(unused_variables)]
10240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10241 where
10242 E: serde::de::Error,
10243 {
10244 Err(serde::de::Error::unknown_field(value, FIELDS))
10245 }
10246 }
10247 deserializer.deserialize_identifier(GeneratedVisitor)
10248 }
10249 }
10250 struct GeneratedVisitor;
10251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10252 type Value = GetDdlProgressRequest;
10253
10254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10255 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
10256 }
10257
10258 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
10259 where
10260 V: serde::de::MapAccess<'de>,
10261 {
10262 while map_.next_key::<GeneratedField>()?.is_some() {
10263 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10264 }
10265 Ok(GetDdlProgressRequest {
10266 })
10267 }
10268 }
10269 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
10270 }
10271}
10272impl serde::Serialize for GetDdlProgressResponse {
10273 #[allow(deprecated)]
10274 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10275 where
10276 S: serde::Serializer,
10277 {
10278 use serde::ser::SerializeStruct;
10279 let mut len = 0;
10280 if !self.ddl_progress.is_empty() {
10281 len += 1;
10282 }
10283 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
10284 if !self.ddl_progress.is_empty() {
10285 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
10286 }
10287 struct_ser.end()
10288 }
10289}
10290impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
10291 #[allow(deprecated)]
10292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10293 where
10294 D: serde::Deserializer<'de>,
10295 {
10296 const FIELDS: &[&str] = &[
10297 "ddl_progress",
10298 "ddlProgress",
10299 ];
10300
10301 #[allow(clippy::enum_variant_names)]
10302 enum GeneratedField {
10303 DdlProgress,
10304 }
10305 impl<'de> serde::Deserialize<'de> for GeneratedField {
10306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10307 where
10308 D: serde::Deserializer<'de>,
10309 {
10310 struct GeneratedVisitor;
10311
10312 impl serde::de::Visitor<'_> for GeneratedVisitor {
10313 type Value = GeneratedField;
10314
10315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10316 write!(formatter, "expected one of: {:?}", &FIELDS)
10317 }
10318
10319 #[allow(unused_variables)]
10320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10321 where
10322 E: serde::de::Error,
10323 {
10324 match value {
10325 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10327 }
10328 }
10329 }
10330 deserializer.deserialize_identifier(GeneratedVisitor)
10331 }
10332 }
10333 struct GeneratedVisitor;
10334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10335 type Value = GetDdlProgressResponse;
10336
10337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10338 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10339 }
10340
10341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10342 where
10343 V: serde::de::MapAccess<'de>,
10344 {
10345 let mut ddl_progress__ = None;
10346 while let Some(k) = map_.next_key()? {
10347 match k {
10348 GeneratedField::DdlProgress => {
10349 if ddl_progress__.is_some() {
10350 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10351 }
10352 ddl_progress__ = Some(map_.next_value()?);
10353 }
10354 }
10355 }
10356 Ok(GetDdlProgressResponse {
10357 ddl_progress: ddl_progress__.unwrap_or_default(),
10358 })
10359 }
10360 }
10361 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10362 }
10363}
10364impl serde::Serialize for GetTableRequest {
10365 #[allow(deprecated)]
10366 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10367 where
10368 S: serde::Serializer,
10369 {
10370 use serde::ser::SerializeStruct;
10371 let mut len = 0;
10372 if !self.database_name.is_empty() {
10373 len += 1;
10374 }
10375 if !self.table_name.is_empty() {
10376 len += 1;
10377 }
10378 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10379 if !self.database_name.is_empty() {
10380 struct_ser.serialize_field("databaseName", &self.database_name)?;
10381 }
10382 if !self.table_name.is_empty() {
10383 struct_ser.serialize_field("tableName", &self.table_name)?;
10384 }
10385 struct_ser.end()
10386 }
10387}
10388impl<'de> serde::Deserialize<'de> for GetTableRequest {
10389 #[allow(deprecated)]
10390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10391 where
10392 D: serde::Deserializer<'de>,
10393 {
10394 const FIELDS: &[&str] = &[
10395 "database_name",
10396 "databaseName",
10397 "table_name",
10398 "tableName",
10399 ];
10400
10401 #[allow(clippy::enum_variant_names)]
10402 enum GeneratedField {
10403 DatabaseName,
10404 TableName,
10405 }
10406 impl<'de> serde::Deserialize<'de> for GeneratedField {
10407 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10408 where
10409 D: serde::Deserializer<'de>,
10410 {
10411 struct GeneratedVisitor;
10412
10413 impl serde::de::Visitor<'_> for GeneratedVisitor {
10414 type Value = GeneratedField;
10415
10416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10417 write!(formatter, "expected one of: {:?}", &FIELDS)
10418 }
10419
10420 #[allow(unused_variables)]
10421 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10422 where
10423 E: serde::de::Error,
10424 {
10425 match value {
10426 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10427 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10428 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10429 }
10430 }
10431 }
10432 deserializer.deserialize_identifier(GeneratedVisitor)
10433 }
10434 }
10435 struct GeneratedVisitor;
10436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10437 type Value = GetTableRequest;
10438
10439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10440 formatter.write_str("struct ddl_service.GetTableRequest")
10441 }
10442
10443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10444 where
10445 V: serde::de::MapAccess<'de>,
10446 {
10447 let mut database_name__ = None;
10448 let mut table_name__ = None;
10449 while let Some(k) = map_.next_key()? {
10450 match k {
10451 GeneratedField::DatabaseName => {
10452 if database_name__.is_some() {
10453 return Err(serde::de::Error::duplicate_field("databaseName"));
10454 }
10455 database_name__ = Some(map_.next_value()?);
10456 }
10457 GeneratedField::TableName => {
10458 if table_name__.is_some() {
10459 return Err(serde::de::Error::duplicate_field("tableName"));
10460 }
10461 table_name__ = Some(map_.next_value()?);
10462 }
10463 }
10464 }
10465 Ok(GetTableRequest {
10466 database_name: database_name__.unwrap_or_default(),
10467 table_name: table_name__.unwrap_or_default(),
10468 })
10469 }
10470 }
10471 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10472 }
10473}
10474impl serde::Serialize for GetTableResponse {
10475 #[allow(deprecated)]
10476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10477 where
10478 S: serde::Serializer,
10479 {
10480 use serde::ser::SerializeStruct;
10481 let mut len = 0;
10482 if self.table.is_some() {
10483 len += 1;
10484 }
10485 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10486 if let Some(v) = self.table.as_ref() {
10487 struct_ser.serialize_field("table", v)?;
10488 }
10489 struct_ser.end()
10490 }
10491}
10492impl<'de> serde::Deserialize<'de> for GetTableResponse {
10493 #[allow(deprecated)]
10494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10495 where
10496 D: serde::Deserializer<'de>,
10497 {
10498 const FIELDS: &[&str] = &[
10499 "table",
10500 ];
10501
10502 #[allow(clippy::enum_variant_names)]
10503 enum GeneratedField {
10504 Table,
10505 }
10506 impl<'de> serde::Deserialize<'de> for GeneratedField {
10507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10508 where
10509 D: serde::Deserializer<'de>,
10510 {
10511 struct GeneratedVisitor;
10512
10513 impl serde::de::Visitor<'_> for GeneratedVisitor {
10514 type Value = GeneratedField;
10515
10516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10517 write!(formatter, "expected one of: {:?}", &FIELDS)
10518 }
10519
10520 #[allow(unused_variables)]
10521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10522 where
10523 E: serde::de::Error,
10524 {
10525 match value {
10526 "table" => Ok(GeneratedField::Table),
10527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10528 }
10529 }
10530 }
10531 deserializer.deserialize_identifier(GeneratedVisitor)
10532 }
10533 }
10534 struct GeneratedVisitor;
10535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10536 type Value = GetTableResponse;
10537
10538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10539 formatter.write_str("struct ddl_service.GetTableResponse")
10540 }
10541
10542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
10543 where
10544 V: serde::de::MapAccess<'de>,
10545 {
10546 let mut table__ = None;
10547 while let Some(k) = map_.next_key()? {
10548 match k {
10549 GeneratedField::Table => {
10550 if table__.is_some() {
10551 return Err(serde::de::Error::duplicate_field("table"));
10552 }
10553 table__ = map_.next_value()?;
10554 }
10555 }
10556 }
10557 Ok(GetTableResponse {
10558 table: table__,
10559 })
10560 }
10561 }
10562 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
10563 }
10564}
10565impl serde::Serialize for GetTablesRequest {
10566 #[allow(deprecated)]
10567 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10568 where
10569 S: serde::Serializer,
10570 {
10571 use serde::ser::SerializeStruct;
10572 let mut len = 0;
10573 if !self.table_ids.is_empty() {
10574 len += 1;
10575 }
10576 if self.include_dropped_tables {
10577 len += 1;
10578 }
10579 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
10580 if !self.table_ids.is_empty() {
10581 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10582 }
10583 if self.include_dropped_tables {
10584 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
10585 }
10586 struct_ser.end()
10587 }
10588}
10589impl<'de> serde::Deserialize<'de> for GetTablesRequest {
10590 #[allow(deprecated)]
10591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10592 where
10593 D: serde::Deserializer<'de>,
10594 {
10595 const FIELDS: &[&str] = &[
10596 "table_ids",
10597 "tableIds",
10598 "include_dropped_tables",
10599 "includeDroppedTables",
10600 ];
10601
10602 #[allow(clippy::enum_variant_names)]
10603 enum GeneratedField {
10604 TableIds,
10605 IncludeDroppedTables,
10606 }
10607 impl<'de> serde::Deserialize<'de> for GeneratedField {
10608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10609 where
10610 D: serde::Deserializer<'de>,
10611 {
10612 struct GeneratedVisitor;
10613
10614 impl serde::de::Visitor<'_> for GeneratedVisitor {
10615 type Value = GeneratedField;
10616
10617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10618 write!(formatter, "expected one of: {:?}", &FIELDS)
10619 }
10620
10621 #[allow(unused_variables)]
10622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10623 where
10624 E: serde::de::Error,
10625 {
10626 match value {
10627 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10628 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
10629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10630 }
10631 }
10632 }
10633 deserializer.deserialize_identifier(GeneratedVisitor)
10634 }
10635 }
10636 struct GeneratedVisitor;
10637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10638 type Value = GetTablesRequest;
10639
10640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10641 formatter.write_str("struct ddl_service.GetTablesRequest")
10642 }
10643
10644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
10645 where
10646 V: serde::de::MapAccess<'de>,
10647 {
10648 let mut table_ids__ = None;
10649 let mut include_dropped_tables__ = None;
10650 while let Some(k) = map_.next_key()? {
10651 match k {
10652 GeneratedField::TableIds => {
10653 if table_ids__.is_some() {
10654 return Err(serde::de::Error::duplicate_field("tableIds"));
10655 }
10656 table_ids__ =
10657 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10658 .into_iter().map(|x| x.0).collect())
10659 ;
10660 }
10661 GeneratedField::IncludeDroppedTables => {
10662 if include_dropped_tables__.is_some() {
10663 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
10664 }
10665 include_dropped_tables__ = Some(map_.next_value()?);
10666 }
10667 }
10668 }
10669 Ok(GetTablesRequest {
10670 table_ids: table_ids__.unwrap_or_default(),
10671 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
10672 })
10673 }
10674 }
10675 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
10676 }
10677}
10678impl serde::Serialize for GetTablesResponse {
10679 #[allow(deprecated)]
10680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10681 where
10682 S: serde::Serializer,
10683 {
10684 use serde::ser::SerializeStruct;
10685 let mut len = 0;
10686 if !self.tables.is_empty() {
10687 len += 1;
10688 }
10689 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
10690 if !self.tables.is_empty() {
10691 struct_ser.serialize_field("tables", &self.tables)?;
10692 }
10693 struct_ser.end()
10694 }
10695}
10696impl<'de> serde::Deserialize<'de> for GetTablesResponse {
10697 #[allow(deprecated)]
10698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10699 where
10700 D: serde::Deserializer<'de>,
10701 {
10702 const FIELDS: &[&str] = &[
10703 "tables",
10704 ];
10705
10706 #[allow(clippy::enum_variant_names)]
10707 enum GeneratedField {
10708 Tables,
10709 }
10710 impl<'de> serde::Deserialize<'de> for GeneratedField {
10711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10712 where
10713 D: serde::Deserializer<'de>,
10714 {
10715 struct GeneratedVisitor;
10716
10717 impl serde::de::Visitor<'_> for GeneratedVisitor {
10718 type Value = GeneratedField;
10719
10720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10721 write!(formatter, "expected one of: {:?}", &FIELDS)
10722 }
10723
10724 #[allow(unused_variables)]
10725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10726 where
10727 E: serde::de::Error,
10728 {
10729 match value {
10730 "tables" => Ok(GeneratedField::Tables),
10731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10732 }
10733 }
10734 }
10735 deserializer.deserialize_identifier(GeneratedVisitor)
10736 }
10737 }
10738 struct GeneratedVisitor;
10739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10740 type Value = GetTablesResponse;
10741
10742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10743 formatter.write_str("struct ddl_service.GetTablesResponse")
10744 }
10745
10746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
10747 where
10748 V: serde::de::MapAccess<'de>,
10749 {
10750 let mut tables__ = None;
10751 while let Some(k) = map_.next_key()? {
10752 match k {
10753 GeneratedField::Tables => {
10754 if tables__.is_some() {
10755 return Err(serde::de::Error::duplicate_field("tables"));
10756 }
10757 tables__ = Some(
10758 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10759 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10760 );
10761 }
10762 }
10763 }
10764 Ok(GetTablesResponse {
10765 tables: tables__.unwrap_or_default(),
10766 })
10767 }
10768 }
10769 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
10770 }
10771}
10772impl serde::Serialize for ListConnectionsRequest {
10773 #[allow(deprecated)]
10774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10775 where
10776 S: serde::Serializer,
10777 {
10778 use serde::ser::SerializeStruct;
10779 let len = 0;
10780 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
10781 struct_ser.end()
10782 }
10783}
10784impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
10785 #[allow(deprecated)]
10786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10787 where
10788 D: serde::Deserializer<'de>,
10789 {
10790 const FIELDS: &[&str] = &[
10791 ];
10792
10793 #[allow(clippy::enum_variant_names)]
10794 enum GeneratedField {
10795 }
10796 impl<'de> serde::Deserialize<'de> for GeneratedField {
10797 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10798 where
10799 D: serde::Deserializer<'de>,
10800 {
10801 struct GeneratedVisitor;
10802
10803 impl serde::de::Visitor<'_> for GeneratedVisitor {
10804 type Value = GeneratedField;
10805
10806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10807 write!(formatter, "expected one of: {:?}", &FIELDS)
10808 }
10809
10810 #[allow(unused_variables)]
10811 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10812 where
10813 E: serde::de::Error,
10814 {
10815 Err(serde::de::Error::unknown_field(value, FIELDS))
10816 }
10817 }
10818 deserializer.deserialize_identifier(GeneratedVisitor)
10819 }
10820 }
10821 struct GeneratedVisitor;
10822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10823 type Value = ListConnectionsRequest;
10824
10825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10826 formatter.write_str("struct ddl_service.ListConnectionsRequest")
10827 }
10828
10829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
10830 where
10831 V: serde::de::MapAccess<'de>,
10832 {
10833 while map_.next_key::<GeneratedField>()?.is_some() {
10834 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10835 }
10836 Ok(ListConnectionsRequest {
10837 })
10838 }
10839 }
10840 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
10841 }
10842}
10843impl serde::Serialize for ListConnectionsResponse {
10844 #[allow(deprecated)]
10845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10846 where
10847 S: serde::Serializer,
10848 {
10849 use serde::ser::SerializeStruct;
10850 let mut len = 0;
10851 if !self.connections.is_empty() {
10852 len += 1;
10853 }
10854 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
10855 if !self.connections.is_empty() {
10856 struct_ser.serialize_field("connections", &self.connections)?;
10857 }
10858 struct_ser.end()
10859 }
10860}
10861impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
10862 #[allow(deprecated)]
10863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10864 where
10865 D: serde::Deserializer<'de>,
10866 {
10867 const FIELDS: &[&str] = &[
10868 "connections",
10869 ];
10870
10871 #[allow(clippy::enum_variant_names)]
10872 enum GeneratedField {
10873 Connections,
10874 }
10875 impl<'de> serde::Deserialize<'de> for GeneratedField {
10876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10877 where
10878 D: serde::Deserializer<'de>,
10879 {
10880 struct GeneratedVisitor;
10881
10882 impl serde::de::Visitor<'_> for GeneratedVisitor {
10883 type Value = GeneratedField;
10884
10885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10886 write!(formatter, "expected one of: {:?}", &FIELDS)
10887 }
10888
10889 #[allow(unused_variables)]
10890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10891 where
10892 E: serde::de::Error,
10893 {
10894 match value {
10895 "connections" => Ok(GeneratedField::Connections),
10896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10897 }
10898 }
10899 }
10900 deserializer.deserialize_identifier(GeneratedVisitor)
10901 }
10902 }
10903 struct GeneratedVisitor;
10904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10905 type Value = ListConnectionsResponse;
10906
10907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10908 formatter.write_str("struct ddl_service.ListConnectionsResponse")
10909 }
10910
10911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
10912 where
10913 V: serde::de::MapAccess<'de>,
10914 {
10915 let mut connections__ = None;
10916 while let Some(k) = map_.next_key()? {
10917 match k {
10918 GeneratedField::Connections => {
10919 if connections__.is_some() {
10920 return Err(serde::de::Error::duplicate_field("connections"));
10921 }
10922 connections__ = Some(map_.next_value()?);
10923 }
10924 }
10925 }
10926 Ok(ListConnectionsResponse {
10927 connections: connections__.unwrap_or_default(),
10928 })
10929 }
10930 }
10931 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
10932 }
10933}
10934impl serde::Serialize for ReplaceJobPlan {
10935 #[allow(deprecated)]
10936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10937 where
10938 S: serde::Serializer,
10939 {
10940 use serde::ser::SerializeStruct;
10941 let mut len = 0;
10942 if self.fragment_graph.is_some() {
10943 len += 1;
10944 }
10945 if self.replace_job.is_some() {
10946 len += 1;
10947 }
10948 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
10949 if let Some(v) = self.fragment_graph.as_ref() {
10950 struct_ser.serialize_field("fragmentGraph", v)?;
10951 }
10952 if let Some(v) = self.replace_job.as_ref() {
10953 match v {
10954 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
10955 struct_ser.serialize_field("replaceTable", v)?;
10956 }
10957 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
10958 struct_ser.serialize_field("replaceSource", v)?;
10959 }
10960 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
10961 struct_ser.serialize_field("replaceMaterializedView", v)?;
10962 }
10963 }
10964 }
10965 struct_ser.end()
10966 }
10967}
10968impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
10969 #[allow(deprecated)]
10970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10971 where
10972 D: serde::Deserializer<'de>,
10973 {
10974 const FIELDS: &[&str] = &[
10975 "fragment_graph",
10976 "fragmentGraph",
10977 "replace_table",
10978 "replaceTable",
10979 "replace_source",
10980 "replaceSource",
10981 "replace_materialized_view",
10982 "replaceMaterializedView",
10983 ];
10984
10985 #[allow(clippy::enum_variant_names)]
10986 enum GeneratedField {
10987 FragmentGraph,
10988 ReplaceTable,
10989 ReplaceSource,
10990 ReplaceMaterializedView,
10991 }
10992 impl<'de> serde::Deserialize<'de> for GeneratedField {
10993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10994 where
10995 D: serde::Deserializer<'de>,
10996 {
10997 struct GeneratedVisitor;
10998
10999 impl serde::de::Visitor<'_> for GeneratedVisitor {
11000 type Value = GeneratedField;
11001
11002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11003 write!(formatter, "expected one of: {:?}", &FIELDS)
11004 }
11005
11006 #[allow(unused_variables)]
11007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11008 where
11009 E: serde::de::Error,
11010 {
11011 match value {
11012 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
11013 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
11014 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
11015 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
11016 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11017 }
11018 }
11019 }
11020 deserializer.deserialize_identifier(GeneratedVisitor)
11021 }
11022 }
11023 struct GeneratedVisitor;
11024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11025 type Value = ReplaceJobPlan;
11026
11027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11028 formatter.write_str("struct ddl_service.ReplaceJobPlan")
11029 }
11030
11031 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
11032 where
11033 V: serde::de::MapAccess<'de>,
11034 {
11035 let mut fragment_graph__ = None;
11036 let mut replace_job__ = None;
11037 while let Some(k) = map_.next_key()? {
11038 match k {
11039 GeneratedField::FragmentGraph => {
11040 if fragment_graph__.is_some() {
11041 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
11042 }
11043 fragment_graph__ = map_.next_value()?;
11044 }
11045 GeneratedField::ReplaceTable => {
11046 if replace_job__.is_some() {
11047 return Err(serde::de::Error::duplicate_field("replaceTable"));
11048 }
11049 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
11050;
11051 }
11052 GeneratedField::ReplaceSource => {
11053 if replace_job__.is_some() {
11054 return Err(serde::de::Error::duplicate_field("replaceSource"));
11055 }
11056 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
11057;
11058 }
11059 GeneratedField::ReplaceMaterializedView => {
11060 if replace_job__.is_some() {
11061 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
11062 }
11063 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
11064;
11065 }
11066 }
11067 }
11068 Ok(ReplaceJobPlan {
11069 fragment_graph: fragment_graph__,
11070 replace_job: replace_job__,
11071 })
11072 }
11073 }
11074 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
11075 }
11076}
11077impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
11078 #[allow(deprecated)]
11079 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11080 where
11081 S: serde::Serializer,
11082 {
11083 use serde::ser::SerializeStruct;
11084 let mut len = 0;
11085 if self.table.is_some() {
11086 len += 1;
11087 }
11088 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
11089 if let Some(v) = self.table.as_ref() {
11090 struct_ser.serialize_field("table", v)?;
11091 }
11092 struct_ser.end()
11093 }
11094}
11095impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
11096 #[allow(deprecated)]
11097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11098 where
11099 D: serde::Deserializer<'de>,
11100 {
11101 const FIELDS: &[&str] = &[
11102 "table",
11103 ];
11104
11105 #[allow(clippy::enum_variant_names)]
11106 enum GeneratedField {
11107 Table,
11108 }
11109 impl<'de> serde::Deserialize<'de> for GeneratedField {
11110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11111 where
11112 D: serde::Deserializer<'de>,
11113 {
11114 struct GeneratedVisitor;
11115
11116 impl serde::de::Visitor<'_> for GeneratedVisitor {
11117 type Value = GeneratedField;
11118
11119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11120 write!(formatter, "expected one of: {:?}", &FIELDS)
11121 }
11122
11123 #[allow(unused_variables)]
11124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11125 where
11126 E: serde::de::Error,
11127 {
11128 match value {
11129 "table" => Ok(GeneratedField::Table),
11130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11131 }
11132 }
11133 }
11134 deserializer.deserialize_identifier(GeneratedVisitor)
11135 }
11136 }
11137 struct GeneratedVisitor;
11138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11139 type Value = replace_job_plan::ReplaceMaterializedView;
11140
11141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11142 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11143 }
11144
11145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11146 where
11147 V: serde::de::MapAccess<'de>,
11148 {
11149 let mut table__ = None;
11150 while let Some(k) = map_.next_key()? {
11151 match k {
11152 GeneratedField::Table => {
11153 if table__.is_some() {
11154 return Err(serde::de::Error::duplicate_field("table"));
11155 }
11156 table__ = map_.next_value()?;
11157 }
11158 }
11159 }
11160 Ok(replace_job_plan::ReplaceMaterializedView {
11161 table: table__,
11162 })
11163 }
11164 }
11165 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11166 }
11167}
11168impl serde::Serialize for replace_job_plan::ReplaceSource {
11169 #[allow(deprecated)]
11170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11171 where
11172 S: serde::Serializer,
11173 {
11174 use serde::ser::SerializeStruct;
11175 let mut len = 0;
11176 if self.source.is_some() {
11177 len += 1;
11178 }
11179 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11180 if let Some(v) = self.source.as_ref() {
11181 struct_ser.serialize_field("source", v)?;
11182 }
11183 struct_ser.end()
11184 }
11185}
11186impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11187 #[allow(deprecated)]
11188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11189 where
11190 D: serde::Deserializer<'de>,
11191 {
11192 const FIELDS: &[&str] = &[
11193 "source",
11194 ];
11195
11196 #[allow(clippy::enum_variant_names)]
11197 enum GeneratedField {
11198 Source,
11199 }
11200 impl<'de> serde::Deserialize<'de> for GeneratedField {
11201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11202 where
11203 D: serde::Deserializer<'de>,
11204 {
11205 struct GeneratedVisitor;
11206
11207 impl serde::de::Visitor<'_> for GeneratedVisitor {
11208 type Value = GeneratedField;
11209
11210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11211 write!(formatter, "expected one of: {:?}", &FIELDS)
11212 }
11213
11214 #[allow(unused_variables)]
11215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11216 where
11217 E: serde::de::Error,
11218 {
11219 match value {
11220 "source" => Ok(GeneratedField::Source),
11221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11222 }
11223 }
11224 }
11225 deserializer.deserialize_identifier(GeneratedVisitor)
11226 }
11227 }
11228 struct GeneratedVisitor;
11229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11230 type Value = replace_job_plan::ReplaceSource;
11231
11232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11233 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
11234 }
11235
11236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
11237 where
11238 V: serde::de::MapAccess<'de>,
11239 {
11240 let mut source__ = None;
11241 while let Some(k) = map_.next_key()? {
11242 match k {
11243 GeneratedField::Source => {
11244 if source__.is_some() {
11245 return Err(serde::de::Error::duplicate_field("source"));
11246 }
11247 source__ = map_.next_value()?;
11248 }
11249 }
11250 }
11251 Ok(replace_job_plan::ReplaceSource {
11252 source: source__,
11253 })
11254 }
11255 }
11256 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
11257 }
11258}
11259impl serde::Serialize for replace_job_plan::ReplaceTable {
11260 #[allow(deprecated)]
11261 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11262 where
11263 S: serde::Serializer,
11264 {
11265 use serde::ser::SerializeStruct;
11266 let mut len = 0;
11267 if self.table.is_some() {
11268 len += 1;
11269 }
11270 if self.source.is_some() {
11271 len += 1;
11272 }
11273 if self.job_type != 0 {
11274 len += 1;
11275 }
11276 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
11277 if let Some(v) = self.table.as_ref() {
11278 struct_ser.serialize_field("table", v)?;
11279 }
11280 if let Some(v) = self.source.as_ref() {
11281 struct_ser.serialize_field("source", v)?;
11282 }
11283 if self.job_type != 0 {
11284 let v = TableJobType::try_from(self.job_type)
11285 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
11286 struct_ser.serialize_field("jobType", &v)?;
11287 }
11288 struct_ser.end()
11289 }
11290}
11291impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
11292 #[allow(deprecated)]
11293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11294 where
11295 D: serde::Deserializer<'de>,
11296 {
11297 const FIELDS: &[&str] = &[
11298 "table",
11299 "source",
11300 "job_type",
11301 "jobType",
11302 ];
11303
11304 #[allow(clippy::enum_variant_names)]
11305 enum GeneratedField {
11306 Table,
11307 Source,
11308 JobType,
11309 }
11310 impl<'de> serde::Deserialize<'de> for GeneratedField {
11311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11312 where
11313 D: serde::Deserializer<'de>,
11314 {
11315 struct GeneratedVisitor;
11316
11317 impl serde::de::Visitor<'_> for GeneratedVisitor {
11318 type Value = GeneratedField;
11319
11320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11321 write!(formatter, "expected one of: {:?}", &FIELDS)
11322 }
11323
11324 #[allow(unused_variables)]
11325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11326 where
11327 E: serde::de::Error,
11328 {
11329 match value {
11330 "table" => Ok(GeneratedField::Table),
11331 "source" => Ok(GeneratedField::Source),
11332 "jobType" | "job_type" => Ok(GeneratedField::JobType),
11333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11334 }
11335 }
11336 }
11337 deserializer.deserialize_identifier(GeneratedVisitor)
11338 }
11339 }
11340 struct GeneratedVisitor;
11341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11342 type Value = replace_job_plan::ReplaceTable;
11343
11344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11345 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11346 }
11347
11348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11349 where
11350 V: serde::de::MapAccess<'de>,
11351 {
11352 let mut table__ = None;
11353 let mut source__ = None;
11354 let mut job_type__ = None;
11355 while let Some(k) = map_.next_key()? {
11356 match k {
11357 GeneratedField::Table => {
11358 if table__.is_some() {
11359 return Err(serde::de::Error::duplicate_field("table"));
11360 }
11361 table__ = map_.next_value()?;
11362 }
11363 GeneratedField::Source => {
11364 if source__.is_some() {
11365 return Err(serde::de::Error::duplicate_field("source"));
11366 }
11367 source__ = map_.next_value()?;
11368 }
11369 GeneratedField::JobType => {
11370 if job_type__.is_some() {
11371 return Err(serde::de::Error::duplicate_field("jobType"));
11372 }
11373 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11374 }
11375 }
11376 }
11377 Ok(replace_job_plan::ReplaceTable {
11378 table: table__,
11379 source: source__,
11380 job_type: job_type__.unwrap_or_default(),
11381 })
11382 }
11383 }
11384 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11385 }
11386}
11387impl serde::Serialize for ReplaceJobPlanRequest {
11388 #[allow(deprecated)]
11389 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11390 where
11391 S: serde::Serializer,
11392 {
11393 use serde::ser::SerializeStruct;
11394 let mut len = 0;
11395 if self.plan.is_some() {
11396 len += 1;
11397 }
11398 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11399 if let Some(v) = self.plan.as_ref() {
11400 struct_ser.serialize_field("plan", v)?;
11401 }
11402 struct_ser.end()
11403 }
11404}
11405impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11406 #[allow(deprecated)]
11407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11408 where
11409 D: serde::Deserializer<'de>,
11410 {
11411 const FIELDS: &[&str] = &[
11412 "plan",
11413 ];
11414
11415 #[allow(clippy::enum_variant_names)]
11416 enum GeneratedField {
11417 Plan,
11418 }
11419 impl<'de> serde::Deserialize<'de> for GeneratedField {
11420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11421 where
11422 D: serde::Deserializer<'de>,
11423 {
11424 struct GeneratedVisitor;
11425
11426 impl serde::de::Visitor<'_> for GeneratedVisitor {
11427 type Value = GeneratedField;
11428
11429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11430 write!(formatter, "expected one of: {:?}", &FIELDS)
11431 }
11432
11433 #[allow(unused_variables)]
11434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11435 where
11436 E: serde::de::Error,
11437 {
11438 match value {
11439 "plan" => Ok(GeneratedField::Plan),
11440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11441 }
11442 }
11443 }
11444 deserializer.deserialize_identifier(GeneratedVisitor)
11445 }
11446 }
11447 struct GeneratedVisitor;
11448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11449 type Value = ReplaceJobPlanRequest;
11450
11451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11452 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11453 }
11454
11455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11456 where
11457 V: serde::de::MapAccess<'de>,
11458 {
11459 let mut plan__ = None;
11460 while let Some(k) = map_.next_key()? {
11461 match k {
11462 GeneratedField::Plan => {
11463 if plan__.is_some() {
11464 return Err(serde::de::Error::duplicate_field("plan"));
11465 }
11466 plan__ = map_.next_value()?;
11467 }
11468 }
11469 }
11470 Ok(ReplaceJobPlanRequest {
11471 plan: plan__,
11472 })
11473 }
11474 }
11475 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11476 }
11477}
11478impl serde::Serialize for ReplaceJobPlanResponse {
11479 #[allow(deprecated)]
11480 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11481 where
11482 S: serde::Serializer,
11483 {
11484 use serde::ser::SerializeStruct;
11485 let mut len = 0;
11486 if self.status.is_some() {
11487 len += 1;
11488 }
11489 if self.version.is_some() {
11490 len += 1;
11491 }
11492 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11493 if let Some(v) = self.status.as_ref() {
11494 struct_ser.serialize_field("status", v)?;
11495 }
11496 if let Some(v) = self.version.as_ref() {
11497 struct_ser.serialize_field("version", v)?;
11498 }
11499 struct_ser.end()
11500 }
11501}
11502impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
11503 #[allow(deprecated)]
11504 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11505 where
11506 D: serde::Deserializer<'de>,
11507 {
11508 const FIELDS: &[&str] = &[
11509 "status",
11510 "version",
11511 ];
11512
11513 #[allow(clippy::enum_variant_names)]
11514 enum GeneratedField {
11515 Status,
11516 Version,
11517 }
11518 impl<'de> serde::Deserialize<'de> for GeneratedField {
11519 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11520 where
11521 D: serde::Deserializer<'de>,
11522 {
11523 struct GeneratedVisitor;
11524
11525 impl serde::de::Visitor<'_> for GeneratedVisitor {
11526 type Value = GeneratedField;
11527
11528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11529 write!(formatter, "expected one of: {:?}", &FIELDS)
11530 }
11531
11532 #[allow(unused_variables)]
11533 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11534 where
11535 E: serde::de::Error,
11536 {
11537 match value {
11538 "status" => Ok(GeneratedField::Status),
11539 "version" => Ok(GeneratedField::Version),
11540 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11541 }
11542 }
11543 }
11544 deserializer.deserialize_identifier(GeneratedVisitor)
11545 }
11546 }
11547 struct GeneratedVisitor;
11548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11549 type Value = ReplaceJobPlanResponse;
11550
11551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11552 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
11553 }
11554
11555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
11556 where
11557 V: serde::de::MapAccess<'de>,
11558 {
11559 let mut status__ = None;
11560 let mut version__ = None;
11561 while let Some(k) = map_.next_key()? {
11562 match k {
11563 GeneratedField::Status => {
11564 if status__.is_some() {
11565 return Err(serde::de::Error::duplicate_field("status"));
11566 }
11567 status__ = map_.next_value()?;
11568 }
11569 GeneratedField::Version => {
11570 if version__.is_some() {
11571 return Err(serde::de::Error::duplicate_field("version"));
11572 }
11573 version__ = map_.next_value()?;
11574 }
11575 }
11576 }
11577 Ok(ReplaceJobPlanResponse {
11578 status: status__,
11579 version: version__,
11580 })
11581 }
11582 }
11583 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
11584 }
11585}
11586impl serde::Serialize for ResetSourceRequest {
11587 #[allow(deprecated)]
11588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11589 where
11590 S: serde::Serializer,
11591 {
11592 use serde::ser::SerializeStruct;
11593 let mut len = 0;
11594 if self.source_id != 0 {
11595 len += 1;
11596 }
11597 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceRequest", len)?;
11598 if self.source_id != 0 {
11599 struct_ser.serialize_field("sourceId", &self.source_id)?;
11600 }
11601 struct_ser.end()
11602 }
11603}
11604impl<'de> serde::Deserialize<'de> for ResetSourceRequest {
11605 #[allow(deprecated)]
11606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11607 where
11608 D: serde::Deserializer<'de>,
11609 {
11610 const FIELDS: &[&str] = &[
11611 "source_id",
11612 "sourceId",
11613 ];
11614
11615 #[allow(clippy::enum_variant_names)]
11616 enum GeneratedField {
11617 SourceId,
11618 }
11619 impl<'de> serde::Deserialize<'de> for GeneratedField {
11620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11621 where
11622 D: serde::Deserializer<'de>,
11623 {
11624 struct GeneratedVisitor;
11625
11626 impl serde::de::Visitor<'_> for GeneratedVisitor {
11627 type Value = GeneratedField;
11628
11629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11630 write!(formatter, "expected one of: {:?}", &FIELDS)
11631 }
11632
11633 #[allow(unused_variables)]
11634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11635 where
11636 E: serde::de::Error,
11637 {
11638 match value {
11639 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11640 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11641 }
11642 }
11643 }
11644 deserializer.deserialize_identifier(GeneratedVisitor)
11645 }
11646 }
11647 struct GeneratedVisitor;
11648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11649 type Value = ResetSourceRequest;
11650
11651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652 formatter.write_str("struct ddl_service.ResetSourceRequest")
11653 }
11654
11655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceRequest, V::Error>
11656 where
11657 V: serde::de::MapAccess<'de>,
11658 {
11659 let mut source_id__ = None;
11660 while let Some(k) = map_.next_key()? {
11661 match k {
11662 GeneratedField::SourceId => {
11663 if source_id__.is_some() {
11664 return Err(serde::de::Error::duplicate_field("sourceId"));
11665 }
11666 source_id__ =
11667 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11668 ;
11669 }
11670 }
11671 }
11672 Ok(ResetSourceRequest {
11673 source_id: source_id__.unwrap_or_default(),
11674 })
11675 }
11676 }
11677 deserializer.deserialize_struct("ddl_service.ResetSourceRequest", FIELDS, GeneratedVisitor)
11678 }
11679}
11680impl serde::Serialize for ResetSourceResponse {
11681 #[allow(deprecated)]
11682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11683 where
11684 S: serde::Serializer,
11685 {
11686 use serde::ser::SerializeStruct;
11687 let mut len = 0;
11688 if self.status.is_some() {
11689 len += 1;
11690 }
11691 if self.version.is_some() {
11692 len += 1;
11693 }
11694 let mut struct_ser = serializer.serialize_struct("ddl_service.ResetSourceResponse", len)?;
11695 if let Some(v) = self.status.as_ref() {
11696 struct_ser.serialize_field("status", v)?;
11697 }
11698 if let Some(v) = self.version.as_ref() {
11699 struct_ser.serialize_field("version", v)?;
11700 }
11701 struct_ser.end()
11702 }
11703}
11704impl<'de> serde::Deserialize<'de> for ResetSourceResponse {
11705 #[allow(deprecated)]
11706 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11707 where
11708 D: serde::Deserializer<'de>,
11709 {
11710 const FIELDS: &[&str] = &[
11711 "status",
11712 "version",
11713 ];
11714
11715 #[allow(clippy::enum_variant_names)]
11716 enum GeneratedField {
11717 Status,
11718 Version,
11719 }
11720 impl<'de> serde::Deserialize<'de> for GeneratedField {
11721 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11722 where
11723 D: serde::Deserializer<'de>,
11724 {
11725 struct GeneratedVisitor;
11726
11727 impl serde::de::Visitor<'_> for GeneratedVisitor {
11728 type Value = GeneratedField;
11729
11730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11731 write!(formatter, "expected one of: {:?}", &FIELDS)
11732 }
11733
11734 #[allow(unused_variables)]
11735 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11736 where
11737 E: serde::de::Error,
11738 {
11739 match value {
11740 "status" => Ok(GeneratedField::Status),
11741 "version" => Ok(GeneratedField::Version),
11742 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11743 }
11744 }
11745 }
11746 deserializer.deserialize_identifier(GeneratedVisitor)
11747 }
11748 }
11749 struct GeneratedVisitor;
11750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11751 type Value = ResetSourceResponse;
11752
11753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11754 formatter.write_str("struct ddl_service.ResetSourceResponse")
11755 }
11756
11757 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceResponse, V::Error>
11758 where
11759 V: serde::de::MapAccess<'de>,
11760 {
11761 let mut status__ = None;
11762 let mut version__ = None;
11763 while let Some(k) = map_.next_key()? {
11764 match k {
11765 GeneratedField::Status => {
11766 if status__.is_some() {
11767 return Err(serde::de::Error::duplicate_field("status"));
11768 }
11769 status__ = map_.next_value()?;
11770 }
11771 GeneratedField::Version => {
11772 if version__.is_some() {
11773 return Err(serde::de::Error::duplicate_field("version"));
11774 }
11775 version__ = map_.next_value()?;
11776 }
11777 }
11778 }
11779 Ok(ResetSourceResponse {
11780 status: status__,
11781 version: version__,
11782 })
11783 }
11784 }
11785 deserializer.deserialize_struct("ddl_service.ResetSourceResponse", FIELDS, GeneratedVisitor)
11786 }
11787}
11788impl serde::Serialize for RisectlListStateTablesRequest {
11789 #[allow(deprecated)]
11790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11791 where
11792 S: serde::Serializer,
11793 {
11794 use serde::ser::SerializeStruct;
11795 let len = 0;
11796 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
11797 struct_ser.end()
11798 }
11799}
11800impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
11801 #[allow(deprecated)]
11802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11803 where
11804 D: serde::Deserializer<'de>,
11805 {
11806 const FIELDS: &[&str] = &[
11807 ];
11808
11809 #[allow(clippy::enum_variant_names)]
11810 enum GeneratedField {
11811 }
11812 impl<'de> serde::Deserialize<'de> for GeneratedField {
11813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11814 where
11815 D: serde::Deserializer<'de>,
11816 {
11817 struct GeneratedVisitor;
11818
11819 impl serde::de::Visitor<'_> for GeneratedVisitor {
11820 type Value = GeneratedField;
11821
11822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11823 write!(formatter, "expected one of: {:?}", &FIELDS)
11824 }
11825
11826 #[allow(unused_variables)]
11827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11828 where
11829 E: serde::de::Error,
11830 {
11831 Err(serde::de::Error::unknown_field(value, FIELDS))
11832 }
11833 }
11834 deserializer.deserialize_identifier(GeneratedVisitor)
11835 }
11836 }
11837 struct GeneratedVisitor;
11838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11839 type Value = RisectlListStateTablesRequest;
11840
11841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11842 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
11843 }
11844
11845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
11846 where
11847 V: serde::de::MapAccess<'de>,
11848 {
11849 while map_.next_key::<GeneratedField>()?.is_some() {
11850 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11851 }
11852 Ok(RisectlListStateTablesRequest {
11853 })
11854 }
11855 }
11856 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
11857 }
11858}
11859impl serde::Serialize for RisectlListStateTablesResponse {
11860 #[allow(deprecated)]
11861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11862 where
11863 S: serde::Serializer,
11864 {
11865 use serde::ser::SerializeStruct;
11866 let mut len = 0;
11867 if !self.tables.is_empty() {
11868 len += 1;
11869 }
11870 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
11871 if !self.tables.is_empty() {
11872 struct_ser.serialize_field("tables", &self.tables)?;
11873 }
11874 struct_ser.end()
11875 }
11876}
11877impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
11878 #[allow(deprecated)]
11879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11880 where
11881 D: serde::Deserializer<'de>,
11882 {
11883 const FIELDS: &[&str] = &[
11884 "tables",
11885 ];
11886
11887 #[allow(clippy::enum_variant_names)]
11888 enum GeneratedField {
11889 Tables,
11890 }
11891 impl<'de> serde::Deserialize<'de> for GeneratedField {
11892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11893 where
11894 D: serde::Deserializer<'de>,
11895 {
11896 struct GeneratedVisitor;
11897
11898 impl serde::de::Visitor<'_> for GeneratedVisitor {
11899 type Value = GeneratedField;
11900
11901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11902 write!(formatter, "expected one of: {:?}", &FIELDS)
11903 }
11904
11905 #[allow(unused_variables)]
11906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11907 where
11908 E: serde::de::Error,
11909 {
11910 match value {
11911 "tables" => Ok(GeneratedField::Tables),
11912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11913 }
11914 }
11915 }
11916 deserializer.deserialize_identifier(GeneratedVisitor)
11917 }
11918 }
11919 struct GeneratedVisitor;
11920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11921 type Value = RisectlListStateTablesResponse;
11922
11923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11924 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
11925 }
11926
11927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
11928 where
11929 V: serde::de::MapAccess<'de>,
11930 {
11931 let mut tables__ = None;
11932 while let Some(k) = map_.next_key()? {
11933 match k {
11934 GeneratedField::Tables => {
11935 if tables__.is_some() {
11936 return Err(serde::de::Error::duplicate_field("tables"));
11937 }
11938 tables__ = Some(map_.next_value()?);
11939 }
11940 }
11941 }
11942 Ok(RisectlListStateTablesResponse {
11943 tables: tables__.unwrap_or_default(),
11944 })
11945 }
11946 }
11947 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
11948 }
11949}
11950impl serde::Serialize for RisectlResumeBackfillRequest {
11951 #[allow(deprecated)]
11952 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11953 where
11954 S: serde::Serializer,
11955 {
11956 use serde::ser::SerializeStruct;
11957 let mut len = 0;
11958 if self.target.is_some() {
11959 len += 1;
11960 }
11961 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillRequest", len)?;
11962 if let Some(v) = self.target.as_ref() {
11963 match v {
11964 risectl_resume_backfill_request::Target::JobId(v) => {
11965 struct_ser.serialize_field("jobId", v)?;
11966 }
11967 risectl_resume_backfill_request::Target::FragmentId(v) => {
11968 struct_ser.serialize_field("fragmentId", v)?;
11969 }
11970 }
11971 }
11972 struct_ser.end()
11973 }
11974}
11975impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillRequest {
11976 #[allow(deprecated)]
11977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11978 where
11979 D: serde::Deserializer<'de>,
11980 {
11981 const FIELDS: &[&str] = &[
11982 "job_id",
11983 "jobId",
11984 "fragment_id",
11985 "fragmentId",
11986 ];
11987
11988 #[allow(clippy::enum_variant_names)]
11989 enum GeneratedField {
11990 JobId,
11991 FragmentId,
11992 }
11993 impl<'de> serde::Deserialize<'de> for GeneratedField {
11994 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11995 where
11996 D: serde::Deserializer<'de>,
11997 {
11998 struct GeneratedVisitor;
11999
12000 impl serde::de::Visitor<'_> for GeneratedVisitor {
12001 type Value = GeneratedField;
12002
12003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12004 write!(formatter, "expected one of: {:?}", &FIELDS)
12005 }
12006
12007 #[allow(unused_variables)]
12008 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12009 where
12010 E: serde::de::Error,
12011 {
12012 match value {
12013 "jobId" | "job_id" => Ok(GeneratedField::JobId),
12014 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12016 }
12017 }
12018 }
12019 deserializer.deserialize_identifier(GeneratedVisitor)
12020 }
12021 }
12022 struct GeneratedVisitor;
12023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12024 type Value = RisectlResumeBackfillRequest;
12025
12026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12027 formatter.write_str("struct ddl_service.RisectlResumeBackfillRequest")
12028 }
12029
12030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillRequest, V::Error>
12031 where
12032 V: serde::de::MapAccess<'de>,
12033 {
12034 let mut target__ = None;
12035 while let Some(k) = map_.next_key()? {
12036 match k {
12037 GeneratedField::JobId => {
12038 if target__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("jobId"));
12040 }
12041 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::JobId(x.0));
12042 }
12043 GeneratedField::FragmentId => {
12044 if target__.is_some() {
12045 return Err(serde::de::Error::duplicate_field("fragmentId"));
12046 }
12047 target__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| risectl_resume_backfill_request::Target::FragmentId(x.0));
12048 }
12049 }
12050 }
12051 Ok(RisectlResumeBackfillRequest {
12052 target: target__,
12053 })
12054 }
12055 }
12056 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillRequest", FIELDS, GeneratedVisitor)
12057 }
12058}
12059impl serde::Serialize for RisectlResumeBackfillResponse {
12060 #[allow(deprecated)]
12061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12062 where
12063 S: serde::Serializer,
12064 {
12065 use serde::ser::SerializeStruct;
12066 let len = 0;
12067 let struct_ser = serializer.serialize_struct("ddl_service.RisectlResumeBackfillResponse", len)?;
12068 struct_ser.end()
12069 }
12070}
12071impl<'de> serde::Deserialize<'de> for RisectlResumeBackfillResponse {
12072 #[allow(deprecated)]
12073 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12074 where
12075 D: serde::Deserializer<'de>,
12076 {
12077 const FIELDS: &[&str] = &[
12078 ];
12079
12080 #[allow(clippy::enum_variant_names)]
12081 enum GeneratedField {
12082 }
12083 impl<'de> serde::Deserialize<'de> for GeneratedField {
12084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12085 where
12086 D: serde::Deserializer<'de>,
12087 {
12088 struct GeneratedVisitor;
12089
12090 impl serde::de::Visitor<'_> for GeneratedVisitor {
12091 type Value = GeneratedField;
12092
12093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12094 write!(formatter, "expected one of: {:?}", &FIELDS)
12095 }
12096
12097 #[allow(unused_variables)]
12098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12099 where
12100 E: serde::de::Error,
12101 {
12102 Err(serde::de::Error::unknown_field(value, FIELDS))
12103 }
12104 }
12105 deserializer.deserialize_identifier(GeneratedVisitor)
12106 }
12107 }
12108 struct GeneratedVisitor;
12109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12110 type Value = RisectlResumeBackfillResponse;
12111
12112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12113 formatter.write_str("struct ddl_service.RisectlResumeBackfillResponse")
12114 }
12115
12116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlResumeBackfillResponse, V::Error>
12117 where
12118 V: serde::de::MapAccess<'de>,
12119 {
12120 while map_.next_key::<GeneratedField>()?.is_some() {
12121 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12122 }
12123 Ok(RisectlResumeBackfillResponse {
12124 })
12125 }
12126 }
12127 deserializer.deserialize_struct("ddl_service.RisectlResumeBackfillResponse", FIELDS, GeneratedVisitor)
12128 }
12129}
12130impl serde::Serialize for SchemaChangeEnvelope {
12131 #[allow(deprecated)]
12132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12133 where
12134 S: serde::Serializer,
12135 {
12136 use serde::ser::SerializeStruct;
12137 let mut len = 0;
12138 if !self.table_changes.is_empty() {
12139 len += 1;
12140 }
12141 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
12142 if !self.table_changes.is_empty() {
12143 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
12144 }
12145 struct_ser.end()
12146 }
12147}
12148impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
12149 #[allow(deprecated)]
12150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12151 where
12152 D: serde::Deserializer<'de>,
12153 {
12154 const FIELDS: &[&str] = &[
12155 "table_changes",
12156 "tableChanges",
12157 ];
12158
12159 #[allow(clippy::enum_variant_names)]
12160 enum GeneratedField {
12161 TableChanges,
12162 }
12163 impl<'de> serde::Deserialize<'de> for GeneratedField {
12164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12165 where
12166 D: serde::Deserializer<'de>,
12167 {
12168 struct GeneratedVisitor;
12169
12170 impl serde::de::Visitor<'_> for GeneratedVisitor {
12171 type Value = GeneratedField;
12172
12173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12174 write!(formatter, "expected one of: {:?}", &FIELDS)
12175 }
12176
12177 #[allow(unused_variables)]
12178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12179 where
12180 E: serde::de::Error,
12181 {
12182 match value {
12183 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
12184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12185 }
12186 }
12187 }
12188 deserializer.deserialize_identifier(GeneratedVisitor)
12189 }
12190 }
12191 struct GeneratedVisitor;
12192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12193 type Value = SchemaChangeEnvelope;
12194
12195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12196 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
12197 }
12198
12199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
12200 where
12201 V: serde::de::MapAccess<'de>,
12202 {
12203 let mut table_changes__ = None;
12204 while let Some(k) = map_.next_key()? {
12205 match k {
12206 GeneratedField::TableChanges => {
12207 if table_changes__.is_some() {
12208 return Err(serde::de::Error::duplicate_field("tableChanges"));
12209 }
12210 table_changes__ = Some(map_.next_value()?);
12211 }
12212 }
12213 }
12214 Ok(SchemaChangeEnvelope {
12215 table_changes: table_changes__.unwrap_or_default(),
12216 })
12217 }
12218 }
12219 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
12220 }
12221}
12222impl serde::Serialize for StreamingJobResourceType {
12223 #[allow(deprecated)]
12224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12225 where
12226 S: serde::Serializer,
12227 {
12228 use serde::ser::SerializeStruct;
12229 let mut len = 0;
12230 if self.resource_type.is_some() {
12231 len += 1;
12232 }
12233 let mut struct_ser = serializer.serialize_struct("ddl_service.StreamingJobResourceType", len)?;
12234 if let Some(v) = self.resource_type.as_ref() {
12235 match v {
12236 streaming_job_resource_type::ResourceType::Regular(v) => {
12237 struct_ser.serialize_field("regular", v)?;
12238 }
12239 streaming_job_resource_type::ResourceType::SpecificResourceGroup(v) => {
12240 struct_ser.serialize_field("specificResourceGroup", v)?;
12241 }
12242 streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup(v) => {
12243 struct_ser.serialize_field("serverlessBackfillResourceGroup", v)?;
12244 }
12245 }
12246 }
12247 struct_ser.end()
12248 }
12249}
12250impl<'de> serde::Deserialize<'de> for StreamingJobResourceType {
12251 #[allow(deprecated)]
12252 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12253 where
12254 D: serde::Deserializer<'de>,
12255 {
12256 const FIELDS: &[&str] = &[
12257 "regular",
12258 "specific_resource_group",
12259 "specificResourceGroup",
12260 "serverless_backfill_resource_group",
12261 "serverlessBackfillResourceGroup",
12262 ];
12263
12264 #[allow(clippy::enum_variant_names)]
12265 enum GeneratedField {
12266 Regular,
12267 SpecificResourceGroup,
12268 ServerlessBackfillResourceGroup,
12269 }
12270 impl<'de> serde::Deserialize<'de> for GeneratedField {
12271 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12272 where
12273 D: serde::Deserializer<'de>,
12274 {
12275 struct GeneratedVisitor;
12276
12277 impl serde::de::Visitor<'_> for GeneratedVisitor {
12278 type Value = GeneratedField;
12279
12280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12281 write!(formatter, "expected one of: {:?}", &FIELDS)
12282 }
12283
12284 #[allow(unused_variables)]
12285 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12286 where
12287 E: serde::de::Error,
12288 {
12289 match value {
12290 "regular" => Ok(GeneratedField::Regular),
12291 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
12292 "serverlessBackfillResourceGroup" | "serverless_backfill_resource_group" => Ok(GeneratedField::ServerlessBackfillResourceGroup),
12293 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12294 }
12295 }
12296 }
12297 deserializer.deserialize_identifier(GeneratedVisitor)
12298 }
12299 }
12300 struct GeneratedVisitor;
12301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12302 type Value = StreamingJobResourceType;
12303
12304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12305 formatter.write_str("struct ddl_service.StreamingJobResourceType")
12306 }
12307
12308 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamingJobResourceType, V::Error>
12309 where
12310 V: serde::de::MapAccess<'de>,
12311 {
12312 let mut resource_type__ = None;
12313 while let Some(k) = map_.next_key()? {
12314 match k {
12315 GeneratedField::Regular => {
12316 if resource_type__.is_some() {
12317 return Err(serde::de::Error::duplicate_field("regular"));
12318 }
12319 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::Regular);
12320 }
12321 GeneratedField::SpecificResourceGroup => {
12322 if resource_type__.is_some() {
12323 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
12324 }
12325 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::SpecificResourceGroup);
12326 }
12327 GeneratedField::ServerlessBackfillResourceGroup => {
12328 if resource_type__.is_some() {
12329 return Err(serde::de::Error::duplicate_field("serverlessBackfillResourceGroup"));
12330 }
12331 resource_type__ = map_.next_value::<::std::option::Option<_>>()?.map(streaming_job_resource_type::ResourceType::ServerlessBackfillResourceGroup);
12332 }
12333 }
12334 }
12335 Ok(StreamingJobResourceType {
12336 resource_type: resource_type__,
12337 })
12338 }
12339 }
12340 deserializer.deserialize_struct("ddl_service.StreamingJobResourceType", FIELDS, GeneratedVisitor)
12341 }
12342}
12343impl serde::Serialize for TableJobType {
12344 #[allow(deprecated)]
12345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12346 where
12347 S: serde::Serializer,
12348 {
12349 let variant = match self {
12350 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
12351 Self::General => "TABLE_JOB_TYPE_GENERAL",
12352 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12353 };
12354 serializer.serialize_str(variant)
12355 }
12356}
12357impl<'de> serde::Deserialize<'de> for TableJobType {
12358 #[allow(deprecated)]
12359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12360 where
12361 D: serde::Deserializer<'de>,
12362 {
12363 const FIELDS: &[&str] = &[
12364 "TABLE_JOB_TYPE_UNSPECIFIED",
12365 "TABLE_JOB_TYPE_GENERAL",
12366 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
12367 ];
12368
12369 struct GeneratedVisitor;
12370
12371 impl serde::de::Visitor<'_> for GeneratedVisitor {
12372 type Value = TableJobType;
12373
12374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12375 write!(formatter, "expected one of: {:?}", &FIELDS)
12376 }
12377
12378 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12379 where
12380 E: serde::de::Error,
12381 {
12382 i32::try_from(v)
12383 .ok()
12384 .and_then(|x| x.try_into().ok())
12385 .ok_or_else(|| {
12386 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12387 })
12388 }
12389
12390 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12391 where
12392 E: serde::de::Error,
12393 {
12394 i32::try_from(v)
12395 .ok()
12396 .and_then(|x| x.try_into().ok())
12397 .ok_or_else(|| {
12398 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12399 })
12400 }
12401
12402 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12403 where
12404 E: serde::de::Error,
12405 {
12406 match value {
12407 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
12408 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
12409 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
12410 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12411 }
12412 }
12413 }
12414 deserializer.deserialize_any(GeneratedVisitor)
12415 }
12416}
12417impl serde::Serialize for TableSchemaChange {
12418 #[allow(deprecated)]
12419 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12420 where
12421 S: serde::Serializer,
12422 {
12423 use serde::ser::SerializeStruct;
12424 let mut len = 0;
12425 if self.change_type != 0 {
12426 len += 1;
12427 }
12428 if !self.cdc_table_id.is_empty() {
12429 len += 1;
12430 }
12431 if !self.columns.is_empty() {
12432 len += 1;
12433 }
12434 if !self.upstream_ddl.is_empty() {
12435 len += 1;
12436 }
12437 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
12438 if self.change_type != 0 {
12439 let v = table_schema_change::TableChangeType::try_from(self.change_type)
12440 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
12441 struct_ser.serialize_field("changeType", &v)?;
12442 }
12443 if !self.cdc_table_id.is_empty() {
12444 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
12445 }
12446 if !self.columns.is_empty() {
12447 struct_ser.serialize_field("columns", &self.columns)?;
12448 }
12449 if !self.upstream_ddl.is_empty() {
12450 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
12451 }
12452 struct_ser.end()
12453 }
12454}
12455impl<'de> serde::Deserialize<'de> for TableSchemaChange {
12456 #[allow(deprecated)]
12457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12458 where
12459 D: serde::Deserializer<'de>,
12460 {
12461 const FIELDS: &[&str] = &[
12462 "change_type",
12463 "changeType",
12464 "cdc_table_id",
12465 "cdcTableId",
12466 "columns",
12467 "upstream_ddl",
12468 "upstreamDdl",
12469 ];
12470
12471 #[allow(clippy::enum_variant_names)]
12472 enum GeneratedField {
12473 ChangeType,
12474 CdcTableId,
12475 Columns,
12476 UpstreamDdl,
12477 }
12478 impl<'de> serde::Deserialize<'de> for GeneratedField {
12479 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12480 where
12481 D: serde::Deserializer<'de>,
12482 {
12483 struct GeneratedVisitor;
12484
12485 impl serde::de::Visitor<'_> for GeneratedVisitor {
12486 type Value = GeneratedField;
12487
12488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12489 write!(formatter, "expected one of: {:?}", &FIELDS)
12490 }
12491
12492 #[allow(unused_variables)]
12493 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12494 where
12495 E: serde::de::Error,
12496 {
12497 match value {
12498 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
12499 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
12500 "columns" => Ok(GeneratedField::Columns),
12501 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
12502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12503 }
12504 }
12505 }
12506 deserializer.deserialize_identifier(GeneratedVisitor)
12507 }
12508 }
12509 struct GeneratedVisitor;
12510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12511 type Value = TableSchemaChange;
12512
12513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12514 formatter.write_str("struct ddl_service.TableSchemaChange")
12515 }
12516
12517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
12518 where
12519 V: serde::de::MapAccess<'de>,
12520 {
12521 let mut change_type__ = None;
12522 let mut cdc_table_id__ = None;
12523 let mut columns__ = None;
12524 let mut upstream_ddl__ = None;
12525 while let Some(k) = map_.next_key()? {
12526 match k {
12527 GeneratedField::ChangeType => {
12528 if change_type__.is_some() {
12529 return Err(serde::de::Error::duplicate_field("changeType"));
12530 }
12531 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
12532 }
12533 GeneratedField::CdcTableId => {
12534 if cdc_table_id__.is_some() {
12535 return Err(serde::de::Error::duplicate_field("cdcTableId"));
12536 }
12537 cdc_table_id__ = Some(map_.next_value()?);
12538 }
12539 GeneratedField::Columns => {
12540 if columns__.is_some() {
12541 return Err(serde::de::Error::duplicate_field("columns"));
12542 }
12543 columns__ = Some(map_.next_value()?);
12544 }
12545 GeneratedField::UpstreamDdl => {
12546 if upstream_ddl__.is_some() {
12547 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
12548 }
12549 upstream_ddl__ = Some(map_.next_value()?);
12550 }
12551 }
12552 }
12553 Ok(TableSchemaChange {
12554 change_type: change_type__.unwrap_or_default(),
12555 cdc_table_id: cdc_table_id__.unwrap_or_default(),
12556 columns: columns__.unwrap_or_default(),
12557 upstream_ddl: upstream_ddl__.unwrap_or_default(),
12558 })
12559 }
12560 }
12561 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
12562 }
12563}
12564impl serde::Serialize for table_schema_change::TableChangeType {
12565 #[allow(deprecated)]
12566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12567 where
12568 S: serde::Serializer,
12569 {
12570 let variant = match self {
12571 Self::Unspecified => "UNSPECIFIED",
12572 Self::Alter => "ALTER",
12573 Self::Create => "CREATE",
12574 Self::Drop => "DROP",
12575 };
12576 serializer.serialize_str(variant)
12577 }
12578}
12579impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
12580 #[allow(deprecated)]
12581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12582 where
12583 D: serde::Deserializer<'de>,
12584 {
12585 const FIELDS: &[&str] = &[
12586 "UNSPECIFIED",
12587 "ALTER",
12588 "CREATE",
12589 "DROP",
12590 ];
12591
12592 struct GeneratedVisitor;
12593
12594 impl serde::de::Visitor<'_> for GeneratedVisitor {
12595 type Value = table_schema_change::TableChangeType;
12596
12597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12598 write!(formatter, "expected one of: {:?}", &FIELDS)
12599 }
12600
12601 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12602 where
12603 E: serde::de::Error,
12604 {
12605 i32::try_from(v)
12606 .ok()
12607 .and_then(|x| x.try_into().ok())
12608 .ok_or_else(|| {
12609 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12610 })
12611 }
12612
12613 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12614 where
12615 E: serde::de::Error,
12616 {
12617 i32::try_from(v)
12618 .ok()
12619 .and_then(|x| x.try_into().ok())
12620 .ok_or_else(|| {
12621 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12622 })
12623 }
12624
12625 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12626 where
12627 E: serde::de::Error,
12628 {
12629 match value {
12630 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
12631 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
12632 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
12633 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
12634 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12635 }
12636 }
12637 }
12638 deserializer.deserialize_any(GeneratedVisitor)
12639 }
12640}
12641impl serde::Serialize for WaitRequest {
12642 #[allow(deprecated)]
12643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12644 where
12645 S: serde::Serializer,
12646 {
12647 use serde::ser::SerializeStruct;
12648 let len = 0;
12649 let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
12650 struct_ser.end()
12651 }
12652}
12653impl<'de> serde::Deserialize<'de> for WaitRequest {
12654 #[allow(deprecated)]
12655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12656 where
12657 D: serde::Deserializer<'de>,
12658 {
12659 const FIELDS: &[&str] = &[
12660 ];
12661
12662 #[allow(clippy::enum_variant_names)]
12663 enum GeneratedField {
12664 }
12665 impl<'de> serde::Deserialize<'de> for GeneratedField {
12666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12667 where
12668 D: serde::Deserializer<'de>,
12669 {
12670 struct GeneratedVisitor;
12671
12672 impl serde::de::Visitor<'_> for GeneratedVisitor {
12673 type Value = GeneratedField;
12674
12675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12676 write!(formatter, "expected one of: {:?}", &FIELDS)
12677 }
12678
12679 #[allow(unused_variables)]
12680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12681 where
12682 E: serde::de::Error,
12683 {
12684 Err(serde::de::Error::unknown_field(value, FIELDS))
12685 }
12686 }
12687 deserializer.deserialize_identifier(GeneratedVisitor)
12688 }
12689 }
12690 struct GeneratedVisitor;
12691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12692 type Value = WaitRequest;
12693
12694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12695 formatter.write_str("struct ddl_service.WaitRequest")
12696 }
12697
12698 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
12699 where
12700 V: serde::de::MapAccess<'de>,
12701 {
12702 while map_.next_key::<GeneratedField>()?.is_some() {
12703 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12704 }
12705 Ok(WaitRequest {
12706 })
12707 }
12708 }
12709 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
12710 }
12711}
12712impl serde::Serialize for WaitResponse {
12713 #[allow(deprecated)]
12714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12715 where
12716 S: serde::Serializer,
12717 {
12718 use serde::ser::SerializeStruct;
12719 let mut len = 0;
12720 if self.version.is_some() {
12721 len += 1;
12722 }
12723 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
12724 if let Some(v) = self.version.as_ref() {
12725 struct_ser.serialize_field("version", v)?;
12726 }
12727 struct_ser.end()
12728 }
12729}
12730impl<'de> serde::Deserialize<'de> for WaitResponse {
12731 #[allow(deprecated)]
12732 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12733 where
12734 D: serde::Deserializer<'de>,
12735 {
12736 const FIELDS: &[&str] = &[
12737 "version",
12738 ];
12739
12740 #[allow(clippy::enum_variant_names)]
12741 enum GeneratedField {
12742 Version,
12743 }
12744 impl<'de> serde::Deserialize<'de> for GeneratedField {
12745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12746 where
12747 D: serde::Deserializer<'de>,
12748 {
12749 struct GeneratedVisitor;
12750
12751 impl serde::de::Visitor<'_> for GeneratedVisitor {
12752 type Value = GeneratedField;
12753
12754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12755 write!(formatter, "expected one of: {:?}", &FIELDS)
12756 }
12757
12758 #[allow(unused_variables)]
12759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12760 where
12761 E: serde::de::Error,
12762 {
12763 match value {
12764 "version" => Ok(GeneratedField::Version),
12765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12766 }
12767 }
12768 }
12769 deserializer.deserialize_identifier(GeneratedVisitor)
12770 }
12771 }
12772 struct GeneratedVisitor;
12773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12774 type Value = WaitResponse;
12775
12776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12777 formatter.write_str("struct ddl_service.WaitResponse")
12778 }
12779
12780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
12781 where
12782 V: serde::de::MapAccess<'de>,
12783 {
12784 let mut version__ = None;
12785 while let Some(k) = map_.next_key()? {
12786 match k {
12787 GeneratedField::Version => {
12788 if version__.is_some() {
12789 return Err(serde::de::Error::duplicate_field("version"));
12790 }
12791 version__ = map_.next_value()?;
12792 }
12793 }
12794 }
12795 Ok(WaitResponse {
12796 version: version__,
12797 })
12798 }
12799 }
12800 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
12801 }
12802}
12803impl serde::Serialize for WaitVersion {
12804 #[allow(deprecated)]
12805 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12806 where
12807 S: serde::Serializer,
12808 {
12809 use serde::ser::SerializeStruct;
12810 let mut len = 0;
12811 if self.catalog_version != 0 {
12812 len += 1;
12813 }
12814 if self.hummock_version_id != 0 {
12815 len += 1;
12816 }
12817 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
12818 if self.catalog_version != 0 {
12819 #[allow(clippy::needless_borrow)]
12820 #[allow(clippy::needless_borrows_for_generic_args)]
12821 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12822 }
12823 if self.hummock_version_id != 0 {
12824 #[allow(clippy::needless_borrow)]
12825 #[allow(clippy::needless_borrows_for_generic_args)]
12826 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
12827 }
12828 struct_ser.end()
12829 }
12830}
12831impl<'de> serde::Deserialize<'de> for WaitVersion {
12832 #[allow(deprecated)]
12833 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12834 where
12835 D: serde::Deserializer<'de>,
12836 {
12837 const FIELDS: &[&str] = &[
12838 "catalog_version",
12839 "catalogVersion",
12840 "hummock_version_id",
12841 "hummockVersionId",
12842 ];
12843
12844 #[allow(clippy::enum_variant_names)]
12845 enum GeneratedField {
12846 CatalogVersion,
12847 HummockVersionId,
12848 }
12849 impl<'de> serde::Deserialize<'de> for GeneratedField {
12850 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12851 where
12852 D: serde::Deserializer<'de>,
12853 {
12854 struct GeneratedVisitor;
12855
12856 impl serde::de::Visitor<'_> for GeneratedVisitor {
12857 type Value = GeneratedField;
12858
12859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12860 write!(formatter, "expected one of: {:?}", &FIELDS)
12861 }
12862
12863 #[allow(unused_variables)]
12864 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12865 where
12866 E: serde::de::Error,
12867 {
12868 match value {
12869 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12870 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
12871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12872 }
12873 }
12874 }
12875 deserializer.deserialize_identifier(GeneratedVisitor)
12876 }
12877 }
12878 struct GeneratedVisitor;
12879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12880 type Value = WaitVersion;
12881
12882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12883 formatter.write_str("struct ddl_service.WaitVersion")
12884 }
12885
12886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
12887 where
12888 V: serde::de::MapAccess<'de>,
12889 {
12890 let mut catalog_version__ = None;
12891 let mut hummock_version_id__ = None;
12892 while let Some(k) = map_.next_key()? {
12893 match k {
12894 GeneratedField::CatalogVersion => {
12895 if catalog_version__.is_some() {
12896 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12897 }
12898 catalog_version__ =
12899 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12900 ;
12901 }
12902 GeneratedField::HummockVersionId => {
12903 if hummock_version_id__.is_some() {
12904 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
12905 }
12906 hummock_version_id__ =
12907 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12908 ;
12909 }
12910 }
12911 }
12912 Ok(WaitVersion {
12913 catalog_version: catalog_version__.unwrap_or_default(),
12914 hummock_version_id: hummock_version_id__.unwrap_or_default(),
12915 })
12916 }
12917 }
12918 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
12919 }
12920}