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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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 }
965 }
966 struct_ser.end()
967 }
968}
969impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
970 #[allow(deprecated)]
971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
972 where
973 D: serde::Deserializer<'de>,
974 {
975 const FIELDS: &[&str] = &[
976 "owner_id",
977 "ownerId",
978 "table_id",
979 "tableId",
980 "view_id",
981 "viewId",
982 "source_id",
983 "sourceId",
984 "sink_id",
985 "sinkId",
986 "schema_id",
987 "schemaId",
988 "database_id",
989 "databaseId",
990 "subscription_id",
991 "subscriptionId",
992 "connection_id",
993 "connectionId",
994 ];
995
996 #[allow(clippy::enum_variant_names)]
997 enum GeneratedField {
998 OwnerId,
999 TableId,
1000 ViewId,
1001 SourceId,
1002 SinkId,
1003 SchemaId,
1004 DatabaseId,
1005 SubscriptionId,
1006 ConnectionId,
1007 }
1008 impl<'de> serde::Deserialize<'de> for GeneratedField {
1009 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1010 where
1011 D: serde::Deserializer<'de>,
1012 {
1013 struct GeneratedVisitor;
1014
1015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1016 type Value = GeneratedField;
1017
1018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1019 write!(formatter, "expected one of: {:?}", &FIELDS)
1020 }
1021
1022 #[allow(unused_variables)]
1023 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1024 where
1025 E: serde::de::Error,
1026 {
1027 match value {
1028 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1029 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1030 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1031 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1032 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1033 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1034 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1035 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1036 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1037 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1038 }
1039 }
1040 }
1041 deserializer.deserialize_identifier(GeneratedVisitor)
1042 }
1043 }
1044 struct GeneratedVisitor;
1045 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1046 type Value = AlterOwnerRequest;
1047
1048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1049 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1050 }
1051
1052 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1053 where
1054 V: serde::de::MapAccess<'de>,
1055 {
1056 let mut owner_id__ = None;
1057 let mut object__ = None;
1058 while let Some(k) = map_.next_key()? {
1059 match k {
1060 GeneratedField::OwnerId => {
1061 if owner_id__.is_some() {
1062 return Err(serde::de::Error::duplicate_field("ownerId"));
1063 }
1064 owner_id__ =
1065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1066 ;
1067 }
1068 GeneratedField::TableId => {
1069 if object__.is_some() {
1070 return Err(serde::de::Error::duplicate_field("tableId"));
1071 }
1072 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1073 }
1074 GeneratedField::ViewId => {
1075 if object__.is_some() {
1076 return Err(serde::de::Error::duplicate_field("viewId"));
1077 }
1078 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1079 }
1080 GeneratedField::SourceId => {
1081 if object__.is_some() {
1082 return Err(serde::de::Error::duplicate_field("sourceId"));
1083 }
1084 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1085 }
1086 GeneratedField::SinkId => {
1087 if object__.is_some() {
1088 return Err(serde::de::Error::duplicate_field("sinkId"));
1089 }
1090 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1091 }
1092 GeneratedField::SchemaId => {
1093 if object__.is_some() {
1094 return Err(serde::de::Error::duplicate_field("schemaId"));
1095 }
1096 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1097 }
1098 GeneratedField::DatabaseId => {
1099 if object__.is_some() {
1100 return Err(serde::de::Error::duplicate_field("databaseId"));
1101 }
1102 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1103 }
1104 GeneratedField::SubscriptionId => {
1105 if object__.is_some() {
1106 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1107 }
1108 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1109 }
1110 GeneratedField::ConnectionId => {
1111 if object__.is_some() {
1112 return Err(serde::de::Error::duplicate_field("connectionId"));
1113 }
1114 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1115 }
1116 }
1117 }
1118 Ok(AlterOwnerRequest {
1119 owner_id: owner_id__.unwrap_or_default(),
1120 object: object__,
1121 })
1122 }
1123 }
1124 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1125 }
1126}
1127impl serde::Serialize for AlterOwnerResponse {
1128 #[allow(deprecated)]
1129 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1130 where
1131 S: serde::Serializer,
1132 {
1133 use serde::ser::SerializeStruct;
1134 let mut len = 0;
1135 if self.status.is_some() {
1136 len += 1;
1137 }
1138 if self.version.is_some() {
1139 len += 1;
1140 }
1141 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1142 if let Some(v) = self.status.as_ref() {
1143 struct_ser.serialize_field("status", v)?;
1144 }
1145 if let Some(v) = self.version.as_ref() {
1146 struct_ser.serialize_field("version", v)?;
1147 }
1148 struct_ser.end()
1149 }
1150}
1151impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1152 #[allow(deprecated)]
1153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1154 where
1155 D: serde::Deserializer<'de>,
1156 {
1157 const FIELDS: &[&str] = &[
1158 "status",
1159 "version",
1160 ];
1161
1162 #[allow(clippy::enum_variant_names)]
1163 enum GeneratedField {
1164 Status,
1165 Version,
1166 }
1167 impl<'de> serde::Deserialize<'de> for GeneratedField {
1168 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1169 where
1170 D: serde::Deserializer<'de>,
1171 {
1172 struct GeneratedVisitor;
1173
1174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1175 type Value = GeneratedField;
1176
1177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1178 write!(formatter, "expected one of: {:?}", &FIELDS)
1179 }
1180
1181 #[allow(unused_variables)]
1182 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1183 where
1184 E: serde::de::Error,
1185 {
1186 match value {
1187 "status" => Ok(GeneratedField::Status),
1188 "version" => Ok(GeneratedField::Version),
1189 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1190 }
1191 }
1192 }
1193 deserializer.deserialize_identifier(GeneratedVisitor)
1194 }
1195 }
1196 struct GeneratedVisitor;
1197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1198 type Value = AlterOwnerResponse;
1199
1200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1201 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1202 }
1203
1204 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1205 where
1206 V: serde::de::MapAccess<'de>,
1207 {
1208 let mut status__ = None;
1209 let mut version__ = None;
1210 while let Some(k) = map_.next_key()? {
1211 match k {
1212 GeneratedField::Status => {
1213 if status__.is_some() {
1214 return Err(serde::de::Error::duplicate_field("status"));
1215 }
1216 status__ = map_.next_value()?;
1217 }
1218 GeneratedField::Version => {
1219 if version__.is_some() {
1220 return Err(serde::de::Error::duplicate_field("version"));
1221 }
1222 version__ = map_.next_value()?;
1223 }
1224 }
1225 }
1226 Ok(AlterOwnerResponse {
1227 status: status__,
1228 version: version__,
1229 })
1230 }
1231 }
1232 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1233 }
1234}
1235impl serde::Serialize for AlterParallelismRequest {
1236 #[allow(deprecated)]
1237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1238 where
1239 S: serde::Serializer,
1240 {
1241 use serde::ser::SerializeStruct;
1242 let mut len = 0;
1243 if self.table_id != 0 {
1244 len += 1;
1245 }
1246 if self.parallelism.is_some() {
1247 len += 1;
1248 }
1249 if self.deferred {
1250 len += 1;
1251 }
1252 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1253 if self.table_id != 0 {
1254 struct_ser.serialize_field("tableId", &self.table_id)?;
1255 }
1256 if let Some(v) = self.parallelism.as_ref() {
1257 struct_ser.serialize_field("parallelism", v)?;
1258 }
1259 if self.deferred {
1260 struct_ser.serialize_field("deferred", &self.deferred)?;
1261 }
1262 struct_ser.end()
1263 }
1264}
1265impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1266 #[allow(deprecated)]
1267 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1268 where
1269 D: serde::Deserializer<'de>,
1270 {
1271 const FIELDS: &[&str] = &[
1272 "table_id",
1273 "tableId",
1274 "parallelism",
1275 "deferred",
1276 ];
1277
1278 #[allow(clippy::enum_variant_names)]
1279 enum GeneratedField {
1280 TableId,
1281 Parallelism,
1282 Deferred,
1283 }
1284 impl<'de> serde::Deserialize<'de> for GeneratedField {
1285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1286 where
1287 D: serde::Deserializer<'de>,
1288 {
1289 struct GeneratedVisitor;
1290
1291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1292 type Value = GeneratedField;
1293
1294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1295 write!(formatter, "expected one of: {:?}", &FIELDS)
1296 }
1297
1298 #[allow(unused_variables)]
1299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1300 where
1301 E: serde::de::Error,
1302 {
1303 match value {
1304 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1305 "parallelism" => Ok(GeneratedField::Parallelism),
1306 "deferred" => Ok(GeneratedField::Deferred),
1307 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1308 }
1309 }
1310 }
1311 deserializer.deserialize_identifier(GeneratedVisitor)
1312 }
1313 }
1314 struct GeneratedVisitor;
1315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1316 type Value = AlterParallelismRequest;
1317
1318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1319 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1320 }
1321
1322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1323 where
1324 V: serde::de::MapAccess<'de>,
1325 {
1326 let mut table_id__ = None;
1327 let mut parallelism__ = None;
1328 let mut deferred__ = None;
1329 while let Some(k) = map_.next_key()? {
1330 match k {
1331 GeneratedField::TableId => {
1332 if table_id__.is_some() {
1333 return Err(serde::de::Error::duplicate_field("tableId"));
1334 }
1335 table_id__ =
1336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1337 ;
1338 }
1339 GeneratedField::Parallelism => {
1340 if parallelism__.is_some() {
1341 return Err(serde::de::Error::duplicate_field("parallelism"));
1342 }
1343 parallelism__ = map_.next_value()?;
1344 }
1345 GeneratedField::Deferred => {
1346 if deferred__.is_some() {
1347 return Err(serde::de::Error::duplicate_field("deferred"));
1348 }
1349 deferred__ = Some(map_.next_value()?);
1350 }
1351 }
1352 }
1353 Ok(AlterParallelismRequest {
1354 table_id: table_id__.unwrap_or_default(),
1355 parallelism: parallelism__,
1356 deferred: deferred__.unwrap_or_default(),
1357 })
1358 }
1359 }
1360 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1361 }
1362}
1363impl serde::Serialize for AlterParallelismResponse {
1364 #[allow(deprecated)]
1365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1366 where
1367 S: serde::Serializer,
1368 {
1369 use serde::ser::SerializeStruct;
1370 let len = 0;
1371 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1372 struct_ser.end()
1373 }
1374}
1375impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1376 #[allow(deprecated)]
1377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1378 where
1379 D: serde::Deserializer<'de>,
1380 {
1381 const FIELDS: &[&str] = &[
1382 ];
1383
1384 #[allow(clippy::enum_variant_names)]
1385 enum GeneratedField {
1386 }
1387 impl<'de> serde::Deserialize<'de> for GeneratedField {
1388 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1389 where
1390 D: serde::Deserializer<'de>,
1391 {
1392 struct GeneratedVisitor;
1393
1394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1395 type Value = GeneratedField;
1396
1397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1398 write!(formatter, "expected one of: {:?}", &FIELDS)
1399 }
1400
1401 #[allow(unused_variables)]
1402 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1403 where
1404 E: serde::de::Error,
1405 {
1406 Err(serde::de::Error::unknown_field(value, FIELDS))
1407 }
1408 }
1409 deserializer.deserialize_identifier(GeneratedVisitor)
1410 }
1411 }
1412 struct GeneratedVisitor;
1413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1414 type Value = AlterParallelismResponse;
1415
1416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1417 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1418 }
1419
1420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1421 where
1422 V: serde::de::MapAccess<'de>,
1423 {
1424 while map_.next_key::<GeneratedField>()?.is_some() {
1425 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1426 }
1427 Ok(AlterParallelismResponse {
1428 })
1429 }
1430 }
1431 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1432 }
1433}
1434impl serde::Serialize for AlterResourceGroupRequest {
1435 #[allow(deprecated)]
1436 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1437 where
1438 S: serde::Serializer,
1439 {
1440 use serde::ser::SerializeStruct;
1441 let mut len = 0;
1442 if self.table_id != 0 {
1443 len += 1;
1444 }
1445 if self.resource_group.is_some() {
1446 len += 1;
1447 }
1448 if self.deferred {
1449 len += 1;
1450 }
1451 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1452 if self.table_id != 0 {
1453 struct_ser.serialize_field("tableId", &self.table_id)?;
1454 }
1455 if let Some(v) = self.resource_group.as_ref() {
1456 struct_ser.serialize_field("resourceGroup", v)?;
1457 }
1458 if self.deferred {
1459 struct_ser.serialize_field("deferred", &self.deferred)?;
1460 }
1461 struct_ser.end()
1462 }
1463}
1464impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1465 #[allow(deprecated)]
1466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1467 where
1468 D: serde::Deserializer<'de>,
1469 {
1470 const FIELDS: &[&str] = &[
1471 "table_id",
1472 "tableId",
1473 "resource_group",
1474 "resourceGroup",
1475 "deferred",
1476 ];
1477
1478 #[allow(clippy::enum_variant_names)]
1479 enum GeneratedField {
1480 TableId,
1481 ResourceGroup,
1482 Deferred,
1483 }
1484 impl<'de> serde::Deserialize<'de> for GeneratedField {
1485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1486 where
1487 D: serde::Deserializer<'de>,
1488 {
1489 struct GeneratedVisitor;
1490
1491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1492 type Value = GeneratedField;
1493
1494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1495 write!(formatter, "expected one of: {:?}", &FIELDS)
1496 }
1497
1498 #[allow(unused_variables)]
1499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1500 where
1501 E: serde::de::Error,
1502 {
1503 match value {
1504 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1505 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1506 "deferred" => Ok(GeneratedField::Deferred),
1507 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1508 }
1509 }
1510 }
1511 deserializer.deserialize_identifier(GeneratedVisitor)
1512 }
1513 }
1514 struct GeneratedVisitor;
1515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1516 type Value = AlterResourceGroupRequest;
1517
1518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1519 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1520 }
1521
1522 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1523 where
1524 V: serde::de::MapAccess<'de>,
1525 {
1526 let mut table_id__ = None;
1527 let mut resource_group__ = None;
1528 let mut deferred__ = None;
1529 while let Some(k) = map_.next_key()? {
1530 match k {
1531 GeneratedField::TableId => {
1532 if table_id__.is_some() {
1533 return Err(serde::de::Error::duplicate_field("tableId"));
1534 }
1535 table_id__ =
1536 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1537 ;
1538 }
1539 GeneratedField::ResourceGroup => {
1540 if resource_group__.is_some() {
1541 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1542 }
1543 resource_group__ = map_.next_value()?;
1544 }
1545 GeneratedField::Deferred => {
1546 if deferred__.is_some() {
1547 return Err(serde::de::Error::duplicate_field("deferred"));
1548 }
1549 deferred__ = Some(map_.next_value()?);
1550 }
1551 }
1552 }
1553 Ok(AlterResourceGroupRequest {
1554 table_id: table_id__.unwrap_or_default(),
1555 resource_group: resource_group__,
1556 deferred: deferred__.unwrap_or_default(),
1557 })
1558 }
1559 }
1560 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1561 }
1562}
1563impl serde::Serialize for AlterResourceGroupResponse {
1564 #[allow(deprecated)]
1565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1566 where
1567 S: serde::Serializer,
1568 {
1569 use serde::ser::SerializeStruct;
1570 let len = 0;
1571 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1572 struct_ser.end()
1573 }
1574}
1575impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1576 #[allow(deprecated)]
1577 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1578 where
1579 D: serde::Deserializer<'de>,
1580 {
1581 const FIELDS: &[&str] = &[
1582 ];
1583
1584 #[allow(clippy::enum_variant_names)]
1585 enum GeneratedField {
1586 }
1587 impl<'de> serde::Deserialize<'de> for GeneratedField {
1588 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1589 where
1590 D: serde::Deserializer<'de>,
1591 {
1592 struct GeneratedVisitor;
1593
1594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1595 type Value = GeneratedField;
1596
1597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1598 write!(formatter, "expected one of: {:?}", &FIELDS)
1599 }
1600
1601 #[allow(unused_variables)]
1602 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1603 where
1604 E: serde::de::Error,
1605 {
1606 Err(serde::de::Error::unknown_field(value, FIELDS))
1607 }
1608 }
1609 deserializer.deserialize_identifier(GeneratedVisitor)
1610 }
1611 }
1612 struct GeneratedVisitor;
1613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1614 type Value = AlterResourceGroupResponse;
1615
1616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1617 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1618 }
1619
1620 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1621 where
1622 V: serde::de::MapAccess<'de>,
1623 {
1624 while map_.next_key::<GeneratedField>()?.is_some() {
1625 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1626 }
1627 Ok(AlterResourceGroupResponse {
1628 })
1629 }
1630 }
1631 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1632 }
1633}
1634impl serde::Serialize for AlterSecretRequest {
1635 #[allow(deprecated)]
1636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1637 where
1638 S: serde::Serializer,
1639 {
1640 use serde::ser::SerializeStruct;
1641 let mut len = 0;
1642 if self.secret_id != 0 {
1643 len += 1;
1644 }
1645 if !self.name.is_empty() {
1646 len += 1;
1647 }
1648 if !self.value.is_empty() {
1649 len += 1;
1650 }
1651 if self.database_id != 0 {
1652 len += 1;
1653 }
1654 if self.schema_id != 0 {
1655 len += 1;
1656 }
1657 if self.owner_id != 0 {
1658 len += 1;
1659 }
1660 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1661 if self.secret_id != 0 {
1662 struct_ser.serialize_field("secretId", &self.secret_id)?;
1663 }
1664 if !self.name.is_empty() {
1665 struct_ser.serialize_field("name", &self.name)?;
1666 }
1667 if !self.value.is_empty() {
1668 #[allow(clippy::needless_borrow)]
1669 #[allow(clippy::needless_borrows_for_generic_args)]
1670 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1671 }
1672 if self.database_id != 0 {
1673 struct_ser.serialize_field("databaseId", &self.database_id)?;
1674 }
1675 if self.schema_id != 0 {
1676 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1677 }
1678 if self.owner_id != 0 {
1679 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1680 }
1681 struct_ser.end()
1682 }
1683}
1684impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1685 #[allow(deprecated)]
1686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1687 where
1688 D: serde::Deserializer<'de>,
1689 {
1690 const FIELDS: &[&str] = &[
1691 "secret_id",
1692 "secretId",
1693 "name",
1694 "value",
1695 "database_id",
1696 "databaseId",
1697 "schema_id",
1698 "schemaId",
1699 "owner_id",
1700 "ownerId",
1701 ];
1702
1703 #[allow(clippy::enum_variant_names)]
1704 enum GeneratedField {
1705 SecretId,
1706 Name,
1707 Value,
1708 DatabaseId,
1709 SchemaId,
1710 OwnerId,
1711 }
1712 impl<'de> serde::Deserialize<'de> for GeneratedField {
1713 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1714 where
1715 D: serde::Deserializer<'de>,
1716 {
1717 struct GeneratedVisitor;
1718
1719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1720 type Value = GeneratedField;
1721
1722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1723 write!(formatter, "expected one of: {:?}", &FIELDS)
1724 }
1725
1726 #[allow(unused_variables)]
1727 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1728 where
1729 E: serde::de::Error,
1730 {
1731 match value {
1732 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1733 "name" => Ok(GeneratedField::Name),
1734 "value" => Ok(GeneratedField::Value),
1735 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1736 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1737 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1739 }
1740 }
1741 }
1742 deserializer.deserialize_identifier(GeneratedVisitor)
1743 }
1744 }
1745 struct GeneratedVisitor;
1746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1747 type Value = AlterSecretRequest;
1748
1749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1750 formatter.write_str("struct ddl_service.AlterSecretRequest")
1751 }
1752
1753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
1754 where
1755 V: serde::de::MapAccess<'de>,
1756 {
1757 let mut secret_id__ = None;
1758 let mut name__ = None;
1759 let mut value__ = None;
1760 let mut database_id__ = None;
1761 let mut schema_id__ = None;
1762 let mut owner_id__ = None;
1763 while let Some(k) = map_.next_key()? {
1764 match k {
1765 GeneratedField::SecretId => {
1766 if secret_id__.is_some() {
1767 return Err(serde::de::Error::duplicate_field("secretId"));
1768 }
1769 secret_id__ =
1770 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1771 ;
1772 }
1773 GeneratedField::Name => {
1774 if name__.is_some() {
1775 return Err(serde::de::Error::duplicate_field("name"));
1776 }
1777 name__ = Some(map_.next_value()?);
1778 }
1779 GeneratedField::Value => {
1780 if value__.is_some() {
1781 return Err(serde::de::Error::duplicate_field("value"));
1782 }
1783 value__ =
1784 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
1785 ;
1786 }
1787 GeneratedField::DatabaseId => {
1788 if database_id__.is_some() {
1789 return Err(serde::de::Error::duplicate_field("databaseId"));
1790 }
1791 database_id__ =
1792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1793 ;
1794 }
1795 GeneratedField::SchemaId => {
1796 if schema_id__.is_some() {
1797 return Err(serde::de::Error::duplicate_field("schemaId"));
1798 }
1799 schema_id__ =
1800 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1801 ;
1802 }
1803 GeneratedField::OwnerId => {
1804 if owner_id__.is_some() {
1805 return Err(serde::de::Error::duplicate_field("ownerId"));
1806 }
1807 owner_id__ =
1808 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1809 ;
1810 }
1811 }
1812 }
1813 Ok(AlterSecretRequest {
1814 secret_id: secret_id__.unwrap_or_default(),
1815 name: name__.unwrap_or_default(),
1816 value: value__.unwrap_or_default(),
1817 database_id: database_id__.unwrap_or_default(),
1818 schema_id: schema_id__.unwrap_or_default(),
1819 owner_id: owner_id__.unwrap_or_default(),
1820 })
1821 }
1822 }
1823 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
1824 }
1825}
1826impl serde::Serialize for AlterSecretResponse {
1827 #[allow(deprecated)]
1828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1829 where
1830 S: serde::Serializer,
1831 {
1832 use serde::ser::SerializeStruct;
1833 let mut len = 0;
1834 if self.version.is_some() {
1835 len += 1;
1836 }
1837 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
1838 if let Some(v) = self.version.as_ref() {
1839 struct_ser.serialize_field("version", v)?;
1840 }
1841 struct_ser.end()
1842 }
1843}
1844impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
1845 #[allow(deprecated)]
1846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1847 where
1848 D: serde::Deserializer<'de>,
1849 {
1850 const FIELDS: &[&str] = &[
1851 "version",
1852 ];
1853
1854 #[allow(clippy::enum_variant_names)]
1855 enum GeneratedField {
1856 Version,
1857 }
1858 impl<'de> serde::Deserialize<'de> for GeneratedField {
1859 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1860 where
1861 D: serde::Deserializer<'de>,
1862 {
1863 struct GeneratedVisitor;
1864
1865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1866 type Value = GeneratedField;
1867
1868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1869 write!(formatter, "expected one of: {:?}", &FIELDS)
1870 }
1871
1872 #[allow(unused_variables)]
1873 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1874 where
1875 E: serde::de::Error,
1876 {
1877 match value {
1878 "version" => Ok(GeneratedField::Version),
1879 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1880 }
1881 }
1882 }
1883 deserializer.deserialize_identifier(GeneratedVisitor)
1884 }
1885 }
1886 struct GeneratedVisitor;
1887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1888 type Value = AlterSecretResponse;
1889
1890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1891 formatter.write_str("struct ddl_service.AlterSecretResponse")
1892 }
1893
1894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
1895 where
1896 V: serde::de::MapAccess<'de>,
1897 {
1898 let mut version__ = None;
1899 while let Some(k) = map_.next_key()? {
1900 match k {
1901 GeneratedField::Version => {
1902 if version__.is_some() {
1903 return Err(serde::de::Error::duplicate_field("version"));
1904 }
1905 version__ = map_.next_value()?;
1906 }
1907 }
1908 }
1909 Ok(AlterSecretResponse {
1910 version: version__,
1911 })
1912 }
1913 }
1914 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
1915 }
1916}
1917impl serde::Serialize for AlterSetSchemaRequest {
1918 #[allow(deprecated)]
1919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1920 where
1921 S: serde::Serializer,
1922 {
1923 use serde::ser::SerializeStruct;
1924 let mut len = 0;
1925 if self.new_schema_id != 0 {
1926 len += 1;
1927 }
1928 if self.object.is_some() {
1929 len += 1;
1930 }
1931 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
1932 if self.new_schema_id != 0 {
1933 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
1934 }
1935 if let Some(v) = self.object.as_ref() {
1936 match v {
1937 alter_set_schema_request::Object::TableId(v) => {
1938 struct_ser.serialize_field("tableId", v)?;
1939 }
1940 alter_set_schema_request::Object::ViewId(v) => {
1941 struct_ser.serialize_field("viewId", v)?;
1942 }
1943 alter_set_schema_request::Object::SourceId(v) => {
1944 struct_ser.serialize_field("sourceId", v)?;
1945 }
1946 alter_set_schema_request::Object::SinkId(v) => {
1947 struct_ser.serialize_field("sinkId", v)?;
1948 }
1949 alter_set_schema_request::Object::FunctionId(v) => {
1950 struct_ser.serialize_field("functionId", v)?;
1951 }
1952 alter_set_schema_request::Object::ConnectionId(v) => {
1953 struct_ser.serialize_field("connectionId", v)?;
1954 }
1955 alter_set_schema_request::Object::SubscriptionId(v) => {
1956 struct_ser.serialize_field("subscriptionId", v)?;
1957 }
1958 }
1959 }
1960 struct_ser.end()
1961 }
1962}
1963impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
1964 #[allow(deprecated)]
1965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1966 where
1967 D: serde::Deserializer<'de>,
1968 {
1969 const FIELDS: &[&str] = &[
1970 "new_schema_id",
1971 "newSchemaId",
1972 "table_id",
1973 "tableId",
1974 "view_id",
1975 "viewId",
1976 "source_id",
1977 "sourceId",
1978 "sink_id",
1979 "sinkId",
1980 "function_id",
1981 "functionId",
1982 "connection_id",
1983 "connectionId",
1984 "subscription_id",
1985 "subscriptionId",
1986 ];
1987
1988 #[allow(clippy::enum_variant_names)]
1989 enum GeneratedField {
1990 NewSchemaId,
1991 TableId,
1992 ViewId,
1993 SourceId,
1994 SinkId,
1995 FunctionId,
1996 ConnectionId,
1997 SubscriptionId,
1998 }
1999 impl<'de> serde::Deserialize<'de> for GeneratedField {
2000 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2001 where
2002 D: serde::Deserializer<'de>,
2003 {
2004 struct GeneratedVisitor;
2005
2006 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2007 type Value = GeneratedField;
2008
2009 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2010 write!(formatter, "expected one of: {:?}", &FIELDS)
2011 }
2012
2013 #[allow(unused_variables)]
2014 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2015 where
2016 E: serde::de::Error,
2017 {
2018 match value {
2019 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2020 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2021 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2022 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2023 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2024 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2025 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2026 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2027 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2028 }
2029 }
2030 }
2031 deserializer.deserialize_identifier(GeneratedVisitor)
2032 }
2033 }
2034 struct GeneratedVisitor;
2035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2036 type Value = AlterSetSchemaRequest;
2037
2038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2039 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2040 }
2041
2042 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2043 where
2044 V: serde::de::MapAccess<'de>,
2045 {
2046 let mut new_schema_id__ = None;
2047 let mut object__ = None;
2048 while let Some(k) = map_.next_key()? {
2049 match k {
2050 GeneratedField::NewSchemaId => {
2051 if new_schema_id__.is_some() {
2052 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2053 }
2054 new_schema_id__ =
2055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2056 ;
2057 }
2058 GeneratedField::TableId => {
2059 if object__.is_some() {
2060 return Err(serde::de::Error::duplicate_field("tableId"));
2061 }
2062 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2063 }
2064 GeneratedField::ViewId => {
2065 if object__.is_some() {
2066 return Err(serde::de::Error::duplicate_field("viewId"));
2067 }
2068 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2069 }
2070 GeneratedField::SourceId => {
2071 if object__.is_some() {
2072 return Err(serde::de::Error::duplicate_field("sourceId"));
2073 }
2074 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2075 }
2076 GeneratedField::SinkId => {
2077 if object__.is_some() {
2078 return Err(serde::de::Error::duplicate_field("sinkId"));
2079 }
2080 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2081 }
2082 GeneratedField::FunctionId => {
2083 if object__.is_some() {
2084 return Err(serde::de::Error::duplicate_field("functionId"));
2085 }
2086 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2087 }
2088 GeneratedField::ConnectionId => {
2089 if object__.is_some() {
2090 return Err(serde::de::Error::duplicate_field("connectionId"));
2091 }
2092 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2093 }
2094 GeneratedField::SubscriptionId => {
2095 if object__.is_some() {
2096 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2097 }
2098 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2099 }
2100 }
2101 }
2102 Ok(AlterSetSchemaRequest {
2103 new_schema_id: new_schema_id__.unwrap_or_default(),
2104 object: object__,
2105 })
2106 }
2107 }
2108 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2109 }
2110}
2111impl serde::Serialize for AlterSetSchemaResponse {
2112 #[allow(deprecated)]
2113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2114 where
2115 S: serde::Serializer,
2116 {
2117 use serde::ser::SerializeStruct;
2118 let mut len = 0;
2119 if self.status.is_some() {
2120 len += 1;
2121 }
2122 if self.version.is_some() {
2123 len += 1;
2124 }
2125 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2126 if let Some(v) = self.status.as_ref() {
2127 struct_ser.serialize_field("status", v)?;
2128 }
2129 if let Some(v) = self.version.as_ref() {
2130 struct_ser.serialize_field("version", v)?;
2131 }
2132 struct_ser.end()
2133 }
2134}
2135impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2136 #[allow(deprecated)]
2137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2138 where
2139 D: serde::Deserializer<'de>,
2140 {
2141 const FIELDS: &[&str] = &[
2142 "status",
2143 "version",
2144 ];
2145
2146 #[allow(clippy::enum_variant_names)]
2147 enum GeneratedField {
2148 Status,
2149 Version,
2150 }
2151 impl<'de> serde::Deserialize<'de> for GeneratedField {
2152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2153 where
2154 D: serde::Deserializer<'de>,
2155 {
2156 struct GeneratedVisitor;
2157
2158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2159 type Value = GeneratedField;
2160
2161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2162 write!(formatter, "expected one of: {:?}", &FIELDS)
2163 }
2164
2165 #[allow(unused_variables)]
2166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2167 where
2168 E: serde::de::Error,
2169 {
2170 match value {
2171 "status" => Ok(GeneratedField::Status),
2172 "version" => Ok(GeneratedField::Version),
2173 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2174 }
2175 }
2176 }
2177 deserializer.deserialize_identifier(GeneratedVisitor)
2178 }
2179 }
2180 struct GeneratedVisitor;
2181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2182 type Value = AlterSetSchemaResponse;
2183
2184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2185 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2186 }
2187
2188 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2189 where
2190 V: serde::de::MapAccess<'de>,
2191 {
2192 let mut status__ = None;
2193 let mut version__ = None;
2194 while let Some(k) = map_.next_key()? {
2195 match k {
2196 GeneratedField::Status => {
2197 if status__.is_some() {
2198 return Err(serde::de::Error::duplicate_field("status"));
2199 }
2200 status__ = map_.next_value()?;
2201 }
2202 GeneratedField::Version => {
2203 if version__.is_some() {
2204 return Err(serde::de::Error::duplicate_field("version"));
2205 }
2206 version__ = map_.next_value()?;
2207 }
2208 }
2209 }
2210 Ok(AlterSetSchemaResponse {
2211 status: status__,
2212 version: version__,
2213 })
2214 }
2215 }
2216 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2217 }
2218}
2219impl serde::Serialize for AlterSourceRequest {
2220 #[allow(deprecated)]
2221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2222 where
2223 S: serde::Serializer,
2224 {
2225 use serde::ser::SerializeStruct;
2226 let mut len = 0;
2227 if self.source.is_some() {
2228 len += 1;
2229 }
2230 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2231 if let Some(v) = self.source.as_ref() {
2232 struct_ser.serialize_field("source", v)?;
2233 }
2234 struct_ser.end()
2235 }
2236}
2237impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2238 #[allow(deprecated)]
2239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2240 where
2241 D: serde::Deserializer<'de>,
2242 {
2243 const FIELDS: &[&str] = &[
2244 "source",
2245 ];
2246
2247 #[allow(clippy::enum_variant_names)]
2248 enum GeneratedField {
2249 Source,
2250 }
2251 impl<'de> serde::Deserialize<'de> for GeneratedField {
2252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2253 where
2254 D: serde::Deserializer<'de>,
2255 {
2256 struct GeneratedVisitor;
2257
2258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2259 type Value = GeneratedField;
2260
2261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2262 write!(formatter, "expected one of: {:?}", &FIELDS)
2263 }
2264
2265 #[allow(unused_variables)]
2266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2267 where
2268 E: serde::de::Error,
2269 {
2270 match value {
2271 "source" => Ok(GeneratedField::Source),
2272 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2273 }
2274 }
2275 }
2276 deserializer.deserialize_identifier(GeneratedVisitor)
2277 }
2278 }
2279 struct GeneratedVisitor;
2280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2281 type Value = AlterSourceRequest;
2282
2283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2284 formatter.write_str("struct ddl_service.AlterSourceRequest")
2285 }
2286
2287 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2288 where
2289 V: serde::de::MapAccess<'de>,
2290 {
2291 let mut source__ = None;
2292 while let Some(k) = map_.next_key()? {
2293 match k {
2294 GeneratedField::Source => {
2295 if source__.is_some() {
2296 return Err(serde::de::Error::duplicate_field("source"));
2297 }
2298 source__ = map_.next_value()?;
2299 }
2300 }
2301 }
2302 Ok(AlterSourceRequest {
2303 source: source__,
2304 })
2305 }
2306 }
2307 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2308 }
2309}
2310impl serde::Serialize for AlterSourceResponse {
2311 #[allow(deprecated)]
2312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2313 where
2314 S: serde::Serializer,
2315 {
2316 use serde::ser::SerializeStruct;
2317 let mut len = 0;
2318 if self.status.is_some() {
2319 len += 1;
2320 }
2321 if self.version.is_some() {
2322 len += 1;
2323 }
2324 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2325 if let Some(v) = self.status.as_ref() {
2326 struct_ser.serialize_field("status", v)?;
2327 }
2328 if let Some(v) = self.version.as_ref() {
2329 struct_ser.serialize_field("version", v)?;
2330 }
2331 struct_ser.end()
2332 }
2333}
2334impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2335 #[allow(deprecated)]
2336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2337 where
2338 D: serde::Deserializer<'de>,
2339 {
2340 const FIELDS: &[&str] = &[
2341 "status",
2342 "version",
2343 ];
2344
2345 #[allow(clippy::enum_variant_names)]
2346 enum GeneratedField {
2347 Status,
2348 Version,
2349 }
2350 impl<'de> serde::Deserialize<'de> for GeneratedField {
2351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2352 where
2353 D: serde::Deserializer<'de>,
2354 {
2355 struct GeneratedVisitor;
2356
2357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2358 type Value = GeneratedField;
2359
2360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2361 write!(formatter, "expected one of: {:?}", &FIELDS)
2362 }
2363
2364 #[allow(unused_variables)]
2365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2366 where
2367 E: serde::de::Error,
2368 {
2369 match value {
2370 "status" => Ok(GeneratedField::Status),
2371 "version" => Ok(GeneratedField::Version),
2372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2373 }
2374 }
2375 }
2376 deserializer.deserialize_identifier(GeneratedVisitor)
2377 }
2378 }
2379 struct GeneratedVisitor;
2380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2381 type Value = AlterSourceResponse;
2382
2383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2384 formatter.write_str("struct ddl_service.AlterSourceResponse")
2385 }
2386
2387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2388 where
2389 V: serde::de::MapAccess<'de>,
2390 {
2391 let mut status__ = None;
2392 let mut version__ = None;
2393 while let Some(k) = map_.next_key()? {
2394 match k {
2395 GeneratedField::Status => {
2396 if status__.is_some() {
2397 return Err(serde::de::Error::duplicate_field("status"));
2398 }
2399 status__ = map_.next_value()?;
2400 }
2401 GeneratedField::Version => {
2402 if version__.is_some() {
2403 return Err(serde::de::Error::duplicate_field("version"));
2404 }
2405 version__ = map_.next_value()?;
2406 }
2407 }
2408 }
2409 Ok(AlterSourceResponse {
2410 status: status__,
2411 version: version__,
2412 })
2413 }
2414 }
2415 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2416 }
2417}
2418impl serde::Serialize for AlterStreamingJobConfigRequest {
2419 #[allow(deprecated)]
2420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2421 where
2422 S: serde::Serializer,
2423 {
2424 use serde::ser::SerializeStruct;
2425 let mut len = 0;
2426 if self.job_id != 0 {
2427 len += 1;
2428 }
2429 if !self.entries_to_add.is_empty() {
2430 len += 1;
2431 }
2432 if !self.keys_to_remove.is_empty() {
2433 len += 1;
2434 }
2435 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigRequest", len)?;
2436 if self.job_id != 0 {
2437 struct_ser.serialize_field("jobId", &self.job_id)?;
2438 }
2439 if !self.entries_to_add.is_empty() {
2440 struct_ser.serialize_field("entriesToAdd", &self.entries_to_add)?;
2441 }
2442 if !self.keys_to_remove.is_empty() {
2443 struct_ser.serialize_field("keysToRemove", &self.keys_to_remove)?;
2444 }
2445 struct_ser.end()
2446 }
2447}
2448impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigRequest {
2449 #[allow(deprecated)]
2450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2451 where
2452 D: serde::Deserializer<'de>,
2453 {
2454 const FIELDS: &[&str] = &[
2455 "job_id",
2456 "jobId",
2457 "entries_to_add",
2458 "entriesToAdd",
2459 "keys_to_remove",
2460 "keysToRemove",
2461 ];
2462
2463 #[allow(clippy::enum_variant_names)]
2464 enum GeneratedField {
2465 JobId,
2466 EntriesToAdd,
2467 KeysToRemove,
2468 }
2469 impl<'de> serde::Deserialize<'de> for GeneratedField {
2470 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2471 where
2472 D: serde::Deserializer<'de>,
2473 {
2474 struct GeneratedVisitor;
2475
2476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2477 type Value = GeneratedField;
2478
2479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2480 write!(formatter, "expected one of: {:?}", &FIELDS)
2481 }
2482
2483 #[allow(unused_variables)]
2484 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2485 where
2486 E: serde::de::Error,
2487 {
2488 match value {
2489 "jobId" | "job_id" => Ok(GeneratedField::JobId),
2490 "entriesToAdd" | "entries_to_add" => Ok(GeneratedField::EntriesToAdd),
2491 "keysToRemove" | "keys_to_remove" => Ok(GeneratedField::KeysToRemove),
2492 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2493 }
2494 }
2495 }
2496 deserializer.deserialize_identifier(GeneratedVisitor)
2497 }
2498 }
2499 struct GeneratedVisitor;
2500 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2501 type Value = AlterStreamingJobConfigRequest;
2502
2503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2504 formatter.write_str("struct ddl_service.AlterStreamingJobConfigRequest")
2505 }
2506
2507 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigRequest, V::Error>
2508 where
2509 V: serde::de::MapAccess<'de>,
2510 {
2511 let mut job_id__ = None;
2512 let mut entries_to_add__ = None;
2513 let mut keys_to_remove__ = None;
2514 while let Some(k) = map_.next_key()? {
2515 match k {
2516 GeneratedField::JobId => {
2517 if job_id__.is_some() {
2518 return Err(serde::de::Error::duplicate_field("jobId"));
2519 }
2520 job_id__ =
2521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2522 ;
2523 }
2524 GeneratedField::EntriesToAdd => {
2525 if entries_to_add__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("entriesToAdd"));
2527 }
2528 entries_to_add__ = Some(
2529 map_.next_value::<std::collections::HashMap<_, _>>()?
2530 );
2531 }
2532 GeneratedField::KeysToRemove => {
2533 if keys_to_remove__.is_some() {
2534 return Err(serde::de::Error::duplicate_field("keysToRemove"));
2535 }
2536 keys_to_remove__ = Some(map_.next_value()?);
2537 }
2538 }
2539 }
2540 Ok(AlterStreamingJobConfigRequest {
2541 job_id: job_id__.unwrap_or_default(),
2542 entries_to_add: entries_to_add__.unwrap_or_default(),
2543 keys_to_remove: keys_to_remove__.unwrap_or_default(),
2544 })
2545 }
2546 }
2547 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigRequest", FIELDS, GeneratedVisitor)
2548 }
2549}
2550impl serde::Serialize for AlterStreamingJobConfigResponse {
2551 #[allow(deprecated)]
2552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2553 where
2554 S: serde::Serializer,
2555 {
2556 use serde::ser::SerializeStruct;
2557 let len = 0;
2558 let struct_ser = serializer.serialize_struct("ddl_service.AlterStreamingJobConfigResponse", len)?;
2559 struct_ser.end()
2560 }
2561}
2562impl<'de> serde::Deserialize<'de> for AlterStreamingJobConfigResponse {
2563 #[allow(deprecated)]
2564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2565 where
2566 D: serde::Deserializer<'de>,
2567 {
2568 const FIELDS: &[&str] = &[
2569 ];
2570
2571 #[allow(clippy::enum_variant_names)]
2572 enum GeneratedField {
2573 }
2574 impl<'de> serde::Deserialize<'de> for GeneratedField {
2575 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2576 where
2577 D: serde::Deserializer<'de>,
2578 {
2579 struct GeneratedVisitor;
2580
2581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2582 type Value = GeneratedField;
2583
2584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2585 write!(formatter, "expected one of: {:?}", &FIELDS)
2586 }
2587
2588 #[allow(unused_variables)]
2589 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2590 where
2591 E: serde::de::Error,
2592 {
2593 Err(serde::de::Error::unknown_field(value, FIELDS))
2594 }
2595 }
2596 deserializer.deserialize_identifier(GeneratedVisitor)
2597 }
2598 }
2599 struct GeneratedVisitor;
2600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2601 type Value = AlterStreamingJobConfigResponse;
2602
2603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2604 formatter.write_str("struct ddl_service.AlterStreamingJobConfigResponse")
2605 }
2606
2607 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterStreamingJobConfigResponse, V::Error>
2608 where
2609 V: serde::de::MapAccess<'de>,
2610 {
2611 while map_.next_key::<GeneratedField>()?.is_some() {
2612 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2613 }
2614 Ok(AlterStreamingJobConfigResponse {
2615 })
2616 }
2617 }
2618 deserializer.deserialize_struct("ddl_service.AlterStreamingJobConfigResponse", FIELDS, GeneratedVisitor)
2619 }
2620}
2621impl serde::Serialize for AlterSwapRenameRequest {
2622 #[allow(deprecated)]
2623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2624 where
2625 S: serde::Serializer,
2626 {
2627 use serde::ser::SerializeStruct;
2628 let mut len = 0;
2629 if self.object.is_some() {
2630 len += 1;
2631 }
2632 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
2633 if let Some(v) = self.object.as_ref() {
2634 match v {
2635 alter_swap_rename_request::Object::Schema(v) => {
2636 struct_ser.serialize_field("schema", v)?;
2637 }
2638 alter_swap_rename_request::Object::Table(v) => {
2639 struct_ser.serialize_field("table", v)?;
2640 }
2641 alter_swap_rename_request::Object::View(v) => {
2642 struct_ser.serialize_field("view", v)?;
2643 }
2644 alter_swap_rename_request::Object::Source(v) => {
2645 struct_ser.serialize_field("source", v)?;
2646 }
2647 alter_swap_rename_request::Object::Sink(v) => {
2648 struct_ser.serialize_field("sink", v)?;
2649 }
2650 alter_swap_rename_request::Object::Subscription(v) => {
2651 struct_ser.serialize_field("subscription", v)?;
2652 }
2653 }
2654 }
2655 struct_ser.end()
2656 }
2657}
2658impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
2659 #[allow(deprecated)]
2660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2661 where
2662 D: serde::Deserializer<'de>,
2663 {
2664 const FIELDS: &[&str] = &[
2665 "schema",
2666 "table",
2667 "view",
2668 "source",
2669 "sink",
2670 "subscription",
2671 ];
2672
2673 #[allow(clippy::enum_variant_names)]
2674 enum GeneratedField {
2675 Schema,
2676 Table,
2677 View,
2678 Source,
2679 Sink,
2680 Subscription,
2681 }
2682 impl<'de> serde::Deserialize<'de> for GeneratedField {
2683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2684 where
2685 D: serde::Deserializer<'de>,
2686 {
2687 struct GeneratedVisitor;
2688
2689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2690 type Value = GeneratedField;
2691
2692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2693 write!(formatter, "expected one of: {:?}", &FIELDS)
2694 }
2695
2696 #[allow(unused_variables)]
2697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2698 where
2699 E: serde::de::Error,
2700 {
2701 match value {
2702 "schema" => Ok(GeneratedField::Schema),
2703 "table" => Ok(GeneratedField::Table),
2704 "view" => Ok(GeneratedField::View),
2705 "source" => Ok(GeneratedField::Source),
2706 "sink" => Ok(GeneratedField::Sink),
2707 "subscription" => Ok(GeneratedField::Subscription),
2708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2709 }
2710 }
2711 }
2712 deserializer.deserialize_identifier(GeneratedVisitor)
2713 }
2714 }
2715 struct GeneratedVisitor;
2716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2717 type Value = AlterSwapRenameRequest;
2718
2719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2720 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
2721 }
2722
2723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
2724 where
2725 V: serde::de::MapAccess<'de>,
2726 {
2727 let mut object__ = None;
2728 while let Some(k) = map_.next_key()? {
2729 match k {
2730 GeneratedField::Schema => {
2731 if object__.is_some() {
2732 return Err(serde::de::Error::duplicate_field("schema"));
2733 }
2734 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
2735;
2736 }
2737 GeneratedField::Table => {
2738 if object__.is_some() {
2739 return Err(serde::de::Error::duplicate_field("table"));
2740 }
2741 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
2742;
2743 }
2744 GeneratedField::View => {
2745 if object__.is_some() {
2746 return Err(serde::de::Error::duplicate_field("view"));
2747 }
2748 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
2749;
2750 }
2751 GeneratedField::Source => {
2752 if object__.is_some() {
2753 return Err(serde::de::Error::duplicate_field("source"));
2754 }
2755 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
2756;
2757 }
2758 GeneratedField::Sink => {
2759 if object__.is_some() {
2760 return Err(serde::de::Error::duplicate_field("sink"));
2761 }
2762 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
2763;
2764 }
2765 GeneratedField::Subscription => {
2766 if object__.is_some() {
2767 return Err(serde::de::Error::duplicate_field("subscription"));
2768 }
2769 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
2770;
2771 }
2772 }
2773 }
2774 Ok(AlterSwapRenameRequest {
2775 object: object__,
2776 })
2777 }
2778 }
2779 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
2780 }
2781}
2782impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
2783 #[allow(deprecated)]
2784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2785 where
2786 S: serde::Serializer,
2787 {
2788 use serde::ser::SerializeStruct;
2789 let mut len = 0;
2790 if self.src_object_id != 0 {
2791 len += 1;
2792 }
2793 if self.dst_object_id != 0 {
2794 len += 1;
2795 }
2796 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
2797 if self.src_object_id != 0 {
2798 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
2799 }
2800 if self.dst_object_id != 0 {
2801 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
2802 }
2803 struct_ser.end()
2804 }
2805}
2806impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
2807 #[allow(deprecated)]
2808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2809 where
2810 D: serde::Deserializer<'de>,
2811 {
2812 const FIELDS: &[&str] = &[
2813 "src_object_id",
2814 "srcObjectId",
2815 "dst_object_id",
2816 "dstObjectId",
2817 ];
2818
2819 #[allow(clippy::enum_variant_names)]
2820 enum GeneratedField {
2821 SrcObjectId,
2822 DstObjectId,
2823 }
2824 impl<'de> serde::Deserialize<'de> for GeneratedField {
2825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2826 where
2827 D: serde::Deserializer<'de>,
2828 {
2829 struct GeneratedVisitor;
2830
2831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2832 type Value = GeneratedField;
2833
2834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2835 write!(formatter, "expected one of: {:?}", &FIELDS)
2836 }
2837
2838 #[allow(unused_variables)]
2839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2840 where
2841 E: serde::de::Error,
2842 {
2843 match value {
2844 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
2845 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
2846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2847 }
2848 }
2849 }
2850 deserializer.deserialize_identifier(GeneratedVisitor)
2851 }
2852 }
2853 struct GeneratedVisitor;
2854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2855 type Value = alter_swap_rename_request::ObjectNameSwapPair;
2856
2857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2858 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
2859 }
2860
2861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
2862 where
2863 V: serde::de::MapAccess<'de>,
2864 {
2865 let mut src_object_id__ = None;
2866 let mut dst_object_id__ = None;
2867 while let Some(k) = map_.next_key()? {
2868 match k {
2869 GeneratedField::SrcObjectId => {
2870 if src_object_id__.is_some() {
2871 return Err(serde::de::Error::duplicate_field("srcObjectId"));
2872 }
2873 src_object_id__ =
2874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2875 ;
2876 }
2877 GeneratedField::DstObjectId => {
2878 if dst_object_id__.is_some() {
2879 return Err(serde::de::Error::duplicate_field("dstObjectId"));
2880 }
2881 dst_object_id__ =
2882 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2883 ;
2884 }
2885 }
2886 }
2887 Ok(alter_swap_rename_request::ObjectNameSwapPair {
2888 src_object_id: src_object_id__.unwrap_or_default(),
2889 dst_object_id: dst_object_id__.unwrap_or_default(),
2890 })
2891 }
2892 }
2893 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
2894 }
2895}
2896impl serde::Serialize for AlterSwapRenameResponse {
2897 #[allow(deprecated)]
2898 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2899 where
2900 S: serde::Serializer,
2901 {
2902 use serde::ser::SerializeStruct;
2903 let mut len = 0;
2904 if self.status.is_some() {
2905 len += 1;
2906 }
2907 if self.version.is_some() {
2908 len += 1;
2909 }
2910 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
2911 if let Some(v) = self.status.as_ref() {
2912 struct_ser.serialize_field("status", v)?;
2913 }
2914 if let Some(v) = self.version.as_ref() {
2915 struct_ser.serialize_field("version", v)?;
2916 }
2917 struct_ser.end()
2918 }
2919}
2920impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
2921 #[allow(deprecated)]
2922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2923 where
2924 D: serde::Deserializer<'de>,
2925 {
2926 const FIELDS: &[&str] = &[
2927 "status",
2928 "version",
2929 ];
2930
2931 #[allow(clippy::enum_variant_names)]
2932 enum GeneratedField {
2933 Status,
2934 Version,
2935 }
2936 impl<'de> serde::Deserialize<'de> for GeneratedField {
2937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2938 where
2939 D: serde::Deserializer<'de>,
2940 {
2941 struct GeneratedVisitor;
2942
2943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2944 type Value = GeneratedField;
2945
2946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2947 write!(formatter, "expected one of: {:?}", &FIELDS)
2948 }
2949
2950 #[allow(unused_variables)]
2951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2952 where
2953 E: serde::de::Error,
2954 {
2955 match value {
2956 "status" => Ok(GeneratedField::Status),
2957 "version" => Ok(GeneratedField::Version),
2958 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2959 }
2960 }
2961 }
2962 deserializer.deserialize_identifier(GeneratedVisitor)
2963 }
2964 }
2965 struct GeneratedVisitor;
2966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2967 type Value = AlterSwapRenameResponse;
2968
2969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2970 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
2971 }
2972
2973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
2974 where
2975 V: serde::de::MapAccess<'de>,
2976 {
2977 let mut status__ = None;
2978 let mut version__ = None;
2979 while let Some(k) = map_.next_key()? {
2980 match k {
2981 GeneratedField::Status => {
2982 if status__.is_some() {
2983 return Err(serde::de::Error::duplicate_field("status"));
2984 }
2985 status__ = map_.next_value()?;
2986 }
2987 GeneratedField::Version => {
2988 if version__.is_some() {
2989 return Err(serde::de::Error::duplicate_field("version"));
2990 }
2991 version__ = map_.next_value()?;
2992 }
2993 }
2994 }
2995 Ok(AlterSwapRenameResponse {
2996 status: status__,
2997 version: version__,
2998 })
2999 }
3000 }
3001 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
3002 }
3003}
3004impl serde::Serialize for AutoSchemaChangeRequest {
3005 #[allow(deprecated)]
3006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3007 where
3008 S: serde::Serializer,
3009 {
3010 use serde::ser::SerializeStruct;
3011 let mut len = 0;
3012 if self.schema_change.is_some() {
3013 len += 1;
3014 }
3015 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
3016 if let Some(v) = self.schema_change.as_ref() {
3017 struct_ser.serialize_field("schemaChange", v)?;
3018 }
3019 struct_ser.end()
3020 }
3021}
3022impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
3023 #[allow(deprecated)]
3024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3025 where
3026 D: serde::Deserializer<'de>,
3027 {
3028 const FIELDS: &[&str] = &[
3029 "schema_change",
3030 "schemaChange",
3031 ];
3032
3033 #[allow(clippy::enum_variant_names)]
3034 enum GeneratedField {
3035 SchemaChange,
3036 }
3037 impl<'de> serde::Deserialize<'de> for GeneratedField {
3038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3039 where
3040 D: serde::Deserializer<'de>,
3041 {
3042 struct GeneratedVisitor;
3043
3044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3045 type Value = GeneratedField;
3046
3047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3048 write!(formatter, "expected one of: {:?}", &FIELDS)
3049 }
3050
3051 #[allow(unused_variables)]
3052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3053 where
3054 E: serde::de::Error,
3055 {
3056 match value {
3057 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
3058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3059 }
3060 }
3061 }
3062 deserializer.deserialize_identifier(GeneratedVisitor)
3063 }
3064 }
3065 struct GeneratedVisitor;
3066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3067 type Value = AutoSchemaChangeRequest;
3068
3069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3070 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
3071 }
3072
3073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
3074 where
3075 V: serde::de::MapAccess<'de>,
3076 {
3077 let mut schema_change__ = None;
3078 while let Some(k) = map_.next_key()? {
3079 match k {
3080 GeneratedField::SchemaChange => {
3081 if schema_change__.is_some() {
3082 return Err(serde::de::Error::duplicate_field("schemaChange"));
3083 }
3084 schema_change__ = map_.next_value()?;
3085 }
3086 }
3087 }
3088 Ok(AutoSchemaChangeRequest {
3089 schema_change: schema_change__,
3090 })
3091 }
3092 }
3093 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
3094 }
3095}
3096impl serde::Serialize for AutoSchemaChangeResponse {
3097 #[allow(deprecated)]
3098 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3099 where
3100 S: serde::Serializer,
3101 {
3102 use serde::ser::SerializeStruct;
3103 let len = 0;
3104 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
3105 struct_ser.end()
3106 }
3107}
3108impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
3109 #[allow(deprecated)]
3110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3111 where
3112 D: serde::Deserializer<'de>,
3113 {
3114 const FIELDS: &[&str] = &[
3115 ];
3116
3117 #[allow(clippy::enum_variant_names)]
3118 enum GeneratedField {
3119 }
3120 impl<'de> serde::Deserialize<'de> for GeneratedField {
3121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3122 where
3123 D: serde::Deserializer<'de>,
3124 {
3125 struct GeneratedVisitor;
3126
3127 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3128 type Value = GeneratedField;
3129
3130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3131 write!(formatter, "expected one of: {:?}", &FIELDS)
3132 }
3133
3134 #[allow(unused_variables)]
3135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3136 where
3137 E: serde::de::Error,
3138 {
3139 Err(serde::de::Error::unknown_field(value, FIELDS))
3140 }
3141 }
3142 deserializer.deserialize_identifier(GeneratedVisitor)
3143 }
3144 }
3145 struct GeneratedVisitor;
3146 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3147 type Value = AutoSchemaChangeResponse;
3148
3149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3150 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
3151 }
3152
3153 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
3154 where
3155 V: serde::de::MapAccess<'de>,
3156 {
3157 while map_.next_key::<GeneratedField>()?.is_some() {
3158 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3159 }
3160 Ok(AutoSchemaChangeResponse {
3161 })
3162 }
3163 }
3164 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
3165 }
3166}
3167impl serde::Serialize for CommentOnRequest {
3168 #[allow(deprecated)]
3169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3170 where
3171 S: serde::Serializer,
3172 {
3173 use serde::ser::SerializeStruct;
3174 let mut len = 0;
3175 if self.comment.is_some() {
3176 len += 1;
3177 }
3178 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
3179 if let Some(v) = self.comment.as_ref() {
3180 struct_ser.serialize_field("comment", v)?;
3181 }
3182 struct_ser.end()
3183 }
3184}
3185impl<'de> serde::Deserialize<'de> for CommentOnRequest {
3186 #[allow(deprecated)]
3187 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3188 where
3189 D: serde::Deserializer<'de>,
3190 {
3191 const FIELDS: &[&str] = &[
3192 "comment",
3193 ];
3194
3195 #[allow(clippy::enum_variant_names)]
3196 enum GeneratedField {
3197 Comment,
3198 }
3199 impl<'de> serde::Deserialize<'de> for GeneratedField {
3200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3201 where
3202 D: serde::Deserializer<'de>,
3203 {
3204 struct GeneratedVisitor;
3205
3206 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3207 type Value = GeneratedField;
3208
3209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3210 write!(formatter, "expected one of: {:?}", &FIELDS)
3211 }
3212
3213 #[allow(unused_variables)]
3214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3215 where
3216 E: serde::de::Error,
3217 {
3218 match value {
3219 "comment" => Ok(GeneratedField::Comment),
3220 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3221 }
3222 }
3223 }
3224 deserializer.deserialize_identifier(GeneratedVisitor)
3225 }
3226 }
3227 struct GeneratedVisitor;
3228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3229 type Value = CommentOnRequest;
3230
3231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3232 formatter.write_str("struct ddl_service.CommentOnRequest")
3233 }
3234
3235 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
3236 where
3237 V: serde::de::MapAccess<'de>,
3238 {
3239 let mut comment__ = None;
3240 while let Some(k) = map_.next_key()? {
3241 match k {
3242 GeneratedField::Comment => {
3243 if comment__.is_some() {
3244 return Err(serde::de::Error::duplicate_field("comment"));
3245 }
3246 comment__ = map_.next_value()?;
3247 }
3248 }
3249 }
3250 Ok(CommentOnRequest {
3251 comment: comment__,
3252 })
3253 }
3254 }
3255 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
3256 }
3257}
3258impl serde::Serialize for CommentOnResponse {
3259 #[allow(deprecated)]
3260 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3261 where
3262 S: serde::Serializer,
3263 {
3264 use serde::ser::SerializeStruct;
3265 let mut len = 0;
3266 if self.status.is_some() {
3267 len += 1;
3268 }
3269 if self.version.is_some() {
3270 len += 1;
3271 }
3272 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
3273 if let Some(v) = self.status.as_ref() {
3274 struct_ser.serialize_field("status", v)?;
3275 }
3276 if let Some(v) = self.version.as_ref() {
3277 struct_ser.serialize_field("version", v)?;
3278 }
3279 struct_ser.end()
3280 }
3281}
3282impl<'de> serde::Deserialize<'de> for CommentOnResponse {
3283 #[allow(deprecated)]
3284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3285 where
3286 D: serde::Deserializer<'de>,
3287 {
3288 const FIELDS: &[&str] = &[
3289 "status",
3290 "version",
3291 ];
3292
3293 #[allow(clippy::enum_variant_names)]
3294 enum GeneratedField {
3295 Status,
3296 Version,
3297 }
3298 impl<'de> serde::Deserialize<'de> for GeneratedField {
3299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3300 where
3301 D: serde::Deserializer<'de>,
3302 {
3303 struct GeneratedVisitor;
3304
3305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3306 type Value = GeneratedField;
3307
3308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3309 write!(formatter, "expected one of: {:?}", &FIELDS)
3310 }
3311
3312 #[allow(unused_variables)]
3313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3314 where
3315 E: serde::de::Error,
3316 {
3317 match value {
3318 "status" => Ok(GeneratedField::Status),
3319 "version" => Ok(GeneratedField::Version),
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 = CommentOnResponse;
3330
3331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3332 formatter.write_str("struct ddl_service.CommentOnResponse")
3333 }
3334
3335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
3336 where
3337 V: serde::de::MapAccess<'de>,
3338 {
3339 let mut status__ = None;
3340 let mut version__ = None;
3341 while let Some(k) = map_.next_key()? {
3342 match k {
3343 GeneratedField::Status => {
3344 if status__.is_some() {
3345 return Err(serde::de::Error::duplicate_field("status"));
3346 }
3347 status__ = map_.next_value()?;
3348 }
3349 GeneratedField::Version => {
3350 if version__.is_some() {
3351 return Err(serde::de::Error::duplicate_field("version"));
3352 }
3353 version__ = map_.next_value()?;
3354 }
3355 }
3356 }
3357 Ok(CommentOnResponse {
3358 status: status__,
3359 version: version__,
3360 })
3361 }
3362 }
3363 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
3364 }
3365}
3366impl serde::Serialize for CompactIcebergTableRequest {
3367 #[allow(deprecated)]
3368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3369 where
3370 S: serde::Serializer,
3371 {
3372 use serde::ser::SerializeStruct;
3373 let mut len = 0;
3374 if self.sink_id != 0 {
3375 len += 1;
3376 }
3377 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
3378 if self.sink_id != 0 {
3379 struct_ser.serialize_field("sinkId", &self.sink_id)?;
3380 }
3381 struct_ser.end()
3382 }
3383}
3384impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
3385 #[allow(deprecated)]
3386 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3387 where
3388 D: serde::Deserializer<'de>,
3389 {
3390 const FIELDS: &[&str] = &[
3391 "sink_id",
3392 "sinkId",
3393 ];
3394
3395 #[allow(clippy::enum_variant_names)]
3396 enum GeneratedField {
3397 SinkId,
3398 }
3399 impl<'de> serde::Deserialize<'de> for GeneratedField {
3400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3401 where
3402 D: serde::Deserializer<'de>,
3403 {
3404 struct GeneratedVisitor;
3405
3406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3407 type Value = GeneratedField;
3408
3409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3410 write!(formatter, "expected one of: {:?}", &FIELDS)
3411 }
3412
3413 #[allow(unused_variables)]
3414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3415 where
3416 E: serde::de::Error,
3417 {
3418 match value {
3419 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
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 = CompactIcebergTableRequest;
3430
3431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3432 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
3433 }
3434
3435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
3436 where
3437 V: serde::de::MapAccess<'de>,
3438 {
3439 let mut sink_id__ = None;
3440 while let Some(k) = map_.next_key()? {
3441 match k {
3442 GeneratedField::SinkId => {
3443 if sink_id__.is_some() {
3444 return Err(serde::de::Error::duplicate_field("sinkId"));
3445 }
3446 sink_id__ =
3447 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3448 ;
3449 }
3450 }
3451 }
3452 Ok(CompactIcebergTableRequest {
3453 sink_id: sink_id__.unwrap_or_default(),
3454 })
3455 }
3456 }
3457 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
3458 }
3459}
3460impl serde::Serialize for CompactIcebergTableResponse {
3461 #[allow(deprecated)]
3462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3463 where
3464 S: serde::Serializer,
3465 {
3466 use serde::ser::SerializeStruct;
3467 let mut len = 0;
3468 if self.status.is_some() {
3469 len += 1;
3470 }
3471 if self.task_id != 0 {
3472 len += 1;
3473 }
3474 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
3475 if let Some(v) = self.status.as_ref() {
3476 struct_ser.serialize_field("status", v)?;
3477 }
3478 if self.task_id != 0 {
3479 #[allow(clippy::needless_borrow)]
3480 #[allow(clippy::needless_borrows_for_generic_args)]
3481 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
3482 }
3483 struct_ser.end()
3484 }
3485}
3486impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
3487 #[allow(deprecated)]
3488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3489 where
3490 D: serde::Deserializer<'de>,
3491 {
3492 const FIELDS: &[&str] = &[
3493 "status",
3494 "task_id",
3495 "taskId",
3496 ];
3497
3498 #[allow(clippy::enum_variant_names)]
3499 enum GeneratedField {
3500 Status,
3501 TaskId,
3502 }
3503 impl<'de> serde::Deserialize<'de> for GeneratedField {
3504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3505 where
3506 D: serde::Deserializer<'de>,
3507 {
3508 struct GeneratedVisitor;
3509
3510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3511 type Value = GeneratedField;
3512
3513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3514 write!(formatter, "expected one of: {:?}", &FIELDS)
3515 }
3516
3517 #[allow(unused_variables)]
3518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3519 where
3520 E: serde::de::Error,
3521 {
3522 match value {
3523 "status" => Ok(GeneratedField::Status),
3524 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
3525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3526 }
3527 }
3528 }
3529 deserializer.deserialize_identifier(GeneratedVisitor)
3530 }
3531 }
3532 struct GeneratedVisitor;
3533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3534 type Value = CompactIcebergTableResponse;
3535
3536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3537 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
3538 }
3539
3540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
3541 where
3542 V: serde::de::MapAccess<'de>,
3543 {
3544 let mut status__ = None;
3545 let mut task_id__ = None;
3546 while let Some(k) = map_.next_key()? {
3547 match k {
3548 GeneratedField::Status => {
3549 if status__.is_some() {
3550 return Err(serde::de::Error::duplicate_field("status"));
3551 }
3552 status__ = map_.next_value()?;
3553 }
3554 GeneratedField::TaskId => {
3555 if task_id__.is_some() {
3556 return Err(serde::de::Error::duplicate_field("taskId"));
3557 }
3558 task_id__ =
3559 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3560 ;
3561 }
3562 }
3563 }
3564 Ok(CompactIcebergTableResponse {
3565 status: status__,
3566 task_id: task_id__.unwrap_or_default(),
3567 })
3568 }
3569 }
3570 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
3571 }
3572}
3573impl serde::Serialize for CreateConnectionRequest {
3574 #[allow(deprecated)]
3575 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3576 where
3577 S: serde::Serializer,
3578 {
3579 use serde::ser::SerializeStruct;
3580 let mut len = 0;
3581 if !self.name.is_empty() {
3582 len += 1;
3583 }
3584 if self.database_id != 0 {
3585 len += 1;
3586 }
3587 if self.schema_id != 0 {
3588 len += 1;
3589 }
3590 if self.owner_id != 0 {
3591 len += 1;
3592 }
3593 if self.payload.is_some() {
3594 len += 1;
3595 }
3596 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
3597 if !self.name.is_empty() {
3598 struct_ser.serialize_field("name", &self.name)?;
3599 }
3600 if self.database_id != 0 {
3601 struct_ser.serialize_field("databaseId", &self.database_id)?;
3602 }
3603 if self.schema_id != 0 {
3604 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3605 }
3606 if self.owner_id != 0 {
3607 struct_ser.serialize_field("ownerId", &self.owner_id)?;
3608 }
3609 if let Some(v) = self.payload.as_ref() {
3610 match v {
3611 create_connection_request::Payload::PrivateLink(v) => {
3612 struct_ser.serialize_field("privateLink", v)?;
3613 }
3614 create_connection_request::Payload::ConnectionParams(v) => {
3615 struct_ser.serialize_field("connectionParams", v)?;
3616 }
3617 }
3618 }
3619 struct_ser.end()
3620 }
3621}
3622impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
3623 #[allow(deprecated)]
3624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3625 where
3626 D: serde::Deserializer<'de>,
3627 {
3628 const FIELDS: &[&str] = &[
3629 "name",
3630 "database_id",
3631 "databaseId",
3632 "schema_id",
3633 "schemaId",
3634 "owner_id",
3635 "ownerId",
3636 "private_link",
3637 "privateLink",
3638 "connection_params",
3639 "connectionParams",
3640 ];
3641
3642 #[allow(clippy::enum_variant_names)]
3643 enum GeneratedField {
3644 Name,
3645 DatabaseId,
3646 SchemaId,
3647 OwnerId,
3648 PrivateLink,
3649 ConnectionParams,
3650 }
3651 impl<'de> serde::Deserialize<'de> for GeneratedField {
3652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3653 where
3654 D: serde::Deserializer<'de>,
3655 {
3656 struct GeneratedVisitor;
3657
3658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3659 type Value = GeneratedField;
3660
3661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3662 write!(formatter, "expected one of: {:?}", &FIELDS)
3663 }
3664
3665 #[allow(unused_variables)]
3666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3667 where
3668 E: serde::de::Error,
3669 {
3670 match value {
3671 "name" => Ok(GeneratedField::Name),
3672 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3673 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3674 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
3675 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
3676 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
3677 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3678 }
3679 }
3680 }
3681 deserializer.deserialize_identifier(GeneratedVisitor)
3682 }
3683 }
3684 struct GeneratedVisitor;
3685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3686 type Value = CreateConnectionRequest;
3687
3688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3689 formatter.write_str("struct ddl_service.CreateConnectionRequest")
3690 }
3691
3692 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
3693 where
3694 V: serde::de::MapAccess<'de>,
3695 {
3696 let mut name__ = None;
3697 let mut database_id__ = None;
3698 let mut schema_id__ = None;
3699 let mut owner_id__ = None;
3700 let mut payload__ = None;
3701 while let Some(k) = map_.next_key()? {
3702 match k {
3703 GeneratedField::Name => {
3704 if name__.is_some() {
3705 return Err(serde::de::Error::duplicate_field("name"));
3706 }
3707 name__ = Some(map_.next_value()?);
3708 }
3709 GeneratedField::DatabaseId => {
3710 if database_id__.is_some() {
3711 return Err(serde::de::Error::duplicate_field("databaseId"));
3712 }
3713 database_id__ =
3714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3715 ;
3716 }
3717 GeneratedField::SchemaId => {
3718 if schema_id__.is_some() {
3719 return Err(serde::de::Error::duplicate_field("schemaId"));
3720 }
3721 schema_id__ =
3722 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3723 ;
3724 }
3725 GeneratedField::OwnerId => {
3726 if owner_id__.is_some() {
3727 return Err(serde::de::Error::duplicate_field("ownerId"));
3728 }
3729 owner_id__ =
3730 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3731 ;
3732 }
3733 GeneratedField::PrivateLink => {
3734 if payload__.is_some() {
3735 return Err(serde::de::Error::duplicate_field("privateLink"));
3736 }
3737 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
3738;
3739 }
3740 GeneratedField::ConnectionParams => {
3741 if payload__.is_some() {
3742 return Err(serde::de::Error::duplicate_field("connectionParams"));
3743 }
3744 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
3745;
3746 }
3747 }
3748 }
3749 Ok(CreateConnectionRequest {
3750 name: name__.unwrap_or_default(),
3751 database_id: database_id__.unwrap_or_default(),
3752 schema_id: schema_id__.unwrap_or_default(),
3753 owner_id: owner_id__.unwrap_or_default(),
3754 payload: payload__,
3755 })
3756 }
3757 }
3758 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
3759 }
3760}
3761impl serde::Serialize for create_connection_request::PrivateLink {
3762 #[allow(deprecated)]
3763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3764 where
3765 S: serde::Serializer,
3766 {
3767 use serde::ser::SerializeStruct;
3768 let mut len = 0;
3769 if self.provider != 0 {
3770 len += 1;
3771 }
3772 if !self.service_name.is_empty() {
3773 len += 1;
3774 }
3775 if self.tags.is_some() {
3776 len += 1;
3777 }
3778 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
3779 if self.provider != 0 {
3780 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
3781 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
3782 struct_ser.serialize_field("provider", &v)?;
3783 }
3784 if !self.service_name.is_empty() {
3785 struct_ser.serialize_field("serviceName", &self.service_name)?;
3786 }
3787 if let Some(v) = self.tags.as_ref() {
3788 struct_ser.serialize_field("tags", v)?;
3789 }
3790 struct_ser.end()
3791 }
3792}
3793impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
3794 #[allow(deprecated)]
3795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3796 where
3797 D: serde::Deserializer<'de>,
3798 {
3799 const FIELDS: &[&str] = &[
3800 "provider",
3801 "service_name",
3802 "serviceName",
3803 "tags",
3804 ];
3805
3806 #[allow(clippy::enum_variant_names)]
3807 enum GeneratedField {
3808 Provider,
3809 ServiceName,
3810 Tags,
3811 }
3812 impl<'de> serde::Deserialize<'de> for GeneratedField {
3813 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3814 where
3815 D: serde::Deserializer<'de>,
3816 {
3817 struct GeneratedVisitor;
3818
3819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3820 type Value = GeneratedField;
3821
3822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3823 write!(formatter, "expected one of: {:?}", &FIELDS)
3824 }
3825
3826 #[allow(unused_variables)]
3827 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3828 where
3829 E: serde::de::Error,
3830 {
3831 match value {
3832 "provider" => Ok(GeneratedField::Provider),
3833 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
3834 "tags" => Ok(GeneratedField::Tags),
3835 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3836 }
3837 }
3838 }
3839 deserializer.deserialize_identifier(GeneratedVisitor)
3840 }
3841 }
3842 struct GeneratedVisitor;
3843 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3844 type Value = create_connection_request::PrivateLink;
3845
3846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3847 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
3848 }
3849
3850 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
3851 where
3852 V: serde::de::MapAccess<'de>,
3853 {
3854 let mut provider__ = None;
3855 let mut service_name__ = None;
3856 let mut tags__ = None;
3857 while let Some(k) = map_.next_key()? {
3858 match k {
3859 GeneratedField::Provider => {
3860 if provider__.is_some() {
3861 return Err(serde::de::Error::duplicate_field("provider"));
3862 }
3863 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
3864 }
3865 GeneratedField::ServiceName => {
3866 if service_name__.is_some() {
3867 return Err(serde::de::Error::duplicate_field("serviceName"));
3868 }
3869 service_name__ = Some(map_.next_value()?);
3870 }
3871 GeneratedField::Tags => {
3872 if tags__.is_some() {
3873 return Err(serde::de::Error::duplicate_field("tags"));
3874 }
3875 tags__ = map_.next_value()?;
3876 }
3877 }
3878 }
3879 Ok(create_connection_request::PrivateLink {
3880 provider: provider__.unwrap_or_default(),
3881 service_name: service_name__.unwrap_or_default(),
3882 tags: tags__,
3883 })
3884 }
3885 }
3886 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
3887 }
3888}
3889impl serde::Serialize for CreateConnectionResponse {
3890 #[allow(deprecated)]
3891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3892 where
3893 S: serde::Serializer,
3894 {
3895 use serde::ser::SerializeStruct;
3896 let mut len = 0;
3897 if self.version.is_some() {
3898 len += 1;
3899 }
3900 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
3901 if let Some(v) = self.version.as_ref() {
3902 struct_ser.serialize_field("version", v)?;
3903 }
3904 struct_ser.end()
3905 }
3906}
3907impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
3908 #[allow(deprecated)]
3909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3910 where
3911 D: serde::Deserializer<'de>,
3912 {
3913 const FIELDS: &[&str] = &[
3914 "version",
3915 ];
3916
3917 #[allow(clippy::enum_variant_names)]
3918 enum GeneratedField {
3919 Version,
3920 }
3921 impl<'de> serde::Deserialize<'de> for GeneratedField {
3922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3923 where
3924 D: serde::Deserializer<'de>,
3925 {
3926 struct GeneratedVisitor;
3927
3928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3929 type Value = GeneratedField;
3930
3931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3932 write!(formatter, "expected one of: {:?}", &FIELDS)
3933 }
3934
3935 #[allow(unused_variables)]
3936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3937 where
3938 E: serde::de::Error,
3939 {
3940 match value {
3941 "version" => Ok(GeneratedField::Version),
3942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3943 }
3944 }
3945 }
3946 deserializer.deserialize_identifier(GeneratedVisitor)
3947 }
3948 }
3949 struct GeneratedVisitor;
3950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3951 type Value = CreateConnectionResponse;
3952
3953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3954 formatter.write_str("struct ddl_service.CreateConnectionResponse")
3955 }
3956
3957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
3958 where
3959 V: serde::de::MapAccess<'de>,
3960 {
3961 let mut version__ = None;
3962 while let Some(k) = map_.next_key()? {
3963 match k {
3964 GeneratedField::Version => {
3965 if version__.is_some() {
3966 return Err(serde::de::Error::duplicate_field("version"));
3967 }
3968 version__ = map_.next_value()?;
3969 }
3970 }
3971 }
3972 Ok(CreateConnectionResponse {
3973 version: version__,
3974 })
3975 }
3976 }
3977 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
3978 }
3979}
3980impl serde::Serialize for CreateDatabaseRequest {
3981 #[allow(deprecated)]
3982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3983 where
3984 S: serde::Serializer,
3985 {
3986 use serde::ser::SerializeStruct;
3987 let mut len = 0;
3988 if self.db.is_some() {
3989 len += 1;
3990 }
3991 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
3992 if let Some(v) = self.db.as_ref() {
3993 struct_ser.serialize_field("db", v)?;
3994 }
3995 struct_ser.end()
3996 }
3997}
3998impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
3999 #[allow(deprecated)]
4000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4001 where
4002 D: serde::Deserializer<'de>,
4003 {
4004 const FIELDS: &[&str] = &[
4005 "db",
4006 ];
4007
4008 #[allow(clippy::enum_variant_names)]
4009 enum GeneratedField {
4010 Db,
4011 }
4012 impl<'de> serde::Deserialize<'de> for GeneratedField {
4013 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4014 where
4015 D: serde::Deserializer<'de>,
4016 {
4017 struct GeneratedVisitor;
4018
4019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4020 type Value = GeneratedField;
4021
4022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4023 write!(formatter, "expected one of: {:?}", &FIELDS)
4024 }
4025
4026 #[allow(unused_variables)]
4027 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4028 where
4029 E: serde::de::Error,
4030 {
4031 match value {
4032 "db" => Ok(GeneratedField::Db),
4033 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4034 }
4035 }
4036 }
4037 deserializer.deserialize_identifier(GeneratedVisitor)
4038 }
4039 }
4040 struct GeneratedVisitor;
4041 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4042 type Value = CreateDatabaseRequest;
4043
4044 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4045 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
4046 }
4047
4048 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
4049 where
4050 V: serde::de::MapAccess<'de>,
4051 {
4052 let mut db__ = None;
4053 while let Some(k) = map_.next_key()? {
4054 match k {
4055 GeneratedField::Db => {
4056 if db__.is_some() {
4057 return Err(serde::de::Error::duplicate_field("db"));
4058 }
4059 db__ = map_.next_value()?;
4060 }
4061 }
4062 }
4063 Ok(CreateDatabaseRequest {
4064 db: db__,
4065 })
4066 }
4067 }
4068 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
4069 }
4070}
4071impl serde::Serialize for CreateDatabaseResponse {
4072 #[allow(deprecated)]
4073 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4074 where
4075 S: serde::Serializer,
4076 {
4077 use serde::ser::SerializeStruct;
4078 let mut len = 0;
4079 if self.status.is_some() {
4080 len += 1;
4081 }
4082 if self.version.is_some() {
4083 len += 1;
4084 }
4085 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
4086 if let Some(v) = self.status.as_ref() {
4087 struct_ser.serialize_field("status", v)?;
4088 }
4089 if let Some(v) = self.version.as_ref() {
4090 struct_ser.serialize_field("version", v)?;
4091 }
4092 struct_ser.end()
4093 }
4094}
4095impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
4096 #[allow(deprecated)]
4097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4098 where
4099 D: serde::Deserializer<'de>,
4100 {
4101 const FIELDS: &[&str] = &[
4102 "status",
4103 "version",
4104 ];
4105
4106 #[allow(clippy::enum_variant_names)]
4107 enum GeneratedField {
4108 Status,
4109 Version,
4110 }
4111 impl<'de> serde::Deserialize<'de> for GeneratedField {
4112 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4113 where
4114 D: serde::Deserializer<'de>,
4115 {
4116 struct GeneratedVisitor;
4117
4118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4119 type Value = GeneratedField;
4120
4121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4122 write!(formatter, "expected one of: {:?}", &FIELDS)
4123 }
4124
4125 #[allow(unused_variables)]
4126 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4127 where
4128 E: serde::de::Error,
4129 {
4130 match value {
4131 "status" => Ok(GeneratedField::Status),
4132 "version" => Ok(GeneratedField::Version),
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 = CreateDatabaseResponse;
4143
4144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4145 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
4146 }
4147
4148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
4149 where
4150 V: serde::de::MapAccess<'de>,
4151 {
4152 let mut status__ = None;
4153 let mut version__ = None;
4154 while let Some(k) = map_.next_key()? {
4155 match k {
4156 GeneratedField::Status => {
4157 if status__.is_some() {
4158 return Err(serde::de::Error::duplicate_field("status"));
4159 }
4160 status__ = map_.next_value()?;
4161 }
4162 GeneratedField::Version => {
4163 if version__.is_some() {
4164 return Err(serde::de::Error::duplicate_field("version"));
4165 }
4166 version__ = map_.next_value()?;
4167 }
4168 }
4169 }
4170 Ok(CreateDatabaseResponse {
4171 status: status__,
4172 version: version__,
4173 })
4174 }
4175 }
4176 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
4177 }
4178}
4179impl serde::Serialize for CreateFunctionRequest {
4180 #[allow(deprecated)]
4181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4182 where
4183 S: serde::Serializer,
4184 {
4185 use serde::ser::SerializeStruct;
4186 let mut len = 0;
4187 if self.function.is_some() {
4188 len += 1;
4189 }
4190 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
4191 if let Some(v) = self.function.as_ref() {
4192 struct_ser.serialize_field("function", v)?;
4193 }
4194 struct_ser.end()
4195 }
4196}
4197impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
4198 #[allow(deprecated)]
4199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4200 where
4201 D: serde::Deserializer<'de>,
4202 {
4203 const FIELDS: &[&str] = &[
4204 "function",
4205 ];
4206
4207 #[allow(clippy::enum_variant_names)]
4208 enum GeneratedField {
4209 Function,
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<'de> serde::de::Visitor<'de> 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 "function" => Ok(GeneratedField::Function),
4232 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4233 }
4234 }
4235 }
4236 deserializer.deserialize_identifier(GeneratedVisitor)
4237 }
4238 }
4239 struct GeneratedVisitor;
4240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4241 type Value = CreateFunctionRequest;
4242
4243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4244 formatter.write_str("struct ddl_service.CreateFunctionRequest")
4245 }
4246
4247 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
4248 where
4249 V: serde::de::MapAccess<'de>,
4250 {
4251 let mut function__ = None;
4252 while let Some(k) = map_.next_key()? {
4253 match k {
4254 GeneratedField::Function => {
4255 if function__.is_some() {
4256 return Err(serde::de::Error::duplicate_field("function"));
4257 }
4258 function__ = map_.next_value()?;
4259 }
4260 }
4261 }
4262 Ok(CreateFunctionRequest {
4263 function: function__,
4264 })
4265 }
4266 }
4267 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
4268 }
4269}
4270impl serde::Serialize for CreateFunctionResponse {
4271 #[allow(deprecated)]
4272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4273 where
4274 S: serde::Serializer,
4275 {
4276 use serde::ser::SerializeStruct;
4277 let mut len = 0;
4278 if self.status.is_some() {
4279 len += 1;
4280 }
4281 if self.version.is_some() {
4282 len += 1;
4283 }
4284 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
4285 if let Some(v) = self.status.as_ref() {
4286 struct_ser.serialize_field("status", v)?;
4287 }
4288 if let Some(v) = self.version.as_ref() {
4289 struct_ser.serialize_field("version", v)?;
4290 }
4291 struct_ser.end()
4292 }
4293}
4294impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
4295 #[allow(deprecated)]
4296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4297 where
4298 D: serde::Deserializer<'de>,
4299 {
4300 const FIELDS: &[&str] = &[
4301 "status",
4302 "version",
4303 ];
4304
4305 #[allow(clippy::enum_variant_names)]
4306 enum GeneratedField {
4307 Status,
4308 Version,
4309 }
4310 impl<'de> serde::Deserialize<'de> for GeneratedField {
4311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4312 where
4313 D: serde::Deserializer<'de>,
4314 {
4315 struct GeneratedVisitor;
4316
4317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4318 type Value = GeneratedField;
4319
4320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4321 write!(formatter, "expected one of: {:?}", &FIELDS)
4322 }
4323
4324 #[allow(unused_variables)]
4325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4326 where
4327 E: serde::de::Error,
4328 {
4329 match value {
4330 "status" => Ok(GeneratedField::Status),
4331 "version" => Ok(GeneratedField::Version),
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 = CreateFunctionResponse;
4342
4343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4344 formatter.write_str("struct ddl_service.CreateFunctionResponse")
4345 }
4346
4347 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
4348 where
4349 V: serde::de::MapAccess<'de>,
4350 {
4351 let mut status__ = None;
4352 let mut version__ = None;
4353 while let Some(k) = map_.next_key()? {
4354 match k {
4355 GeneratedField::Status => {
4356 if status__.is_some() {
4357 return Err(serde::de::Error::duplicate_field("status"));
4358 }
4359 status__ = map_.next_value()?;
4360 }
4361 GeneratedField::Version => {
4362 if version__.is_some() {
4363 return Err(serde::de::Error::duplicate_field("version"));
4364 }
4365 version__ = map_.next_value()?;
4366 }
4367 }
4368 }
4369 Ok(CreateFunctionResponse {
4370 status: status__,
4371 version: version__,
4372 })
4373 }
4374 }
4375 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
4376 }
4377}
4378impl serde::Serialize for CreateIcebergTableRequest {
4379 #[allow(deprecated)]
4380 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4381 where
4382 S: serde::Serializer,
4383 {
4384 use serde::ser::SerializeStruct;
4385 let mut len = 0;
4386 if self.table_info.is_some() {
4387 len += 1;
4388 }
4389 if self.sink_info.is_some() {
4390 len += 1;
4391 }
4392 if self.iceberg_source.is_some() {
4393 len += 1;
4394 }
4395 if self.if_not_exists {
4396 len += 1;
4397 }
4398 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
4399 if let Some(v) = self.table_info.as_ref() {
4400 struct_ser.serialize_field("tableInfo", v)?;
4401 }
4402 if let Some(v) = self.sink_info.as_ref() {
4403 struct_ser.serialize_field("sinkInfo", v)?;
4404 }
4405 if let Some(v) = self.iceberg_source.as_ref() {
4406 struct_ser.serialize_field("icebergSource", v)?;
4407 }
4408 if self.if_not_exists {
4409 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4410 }
4411 struct_ser.end()
4412 }
4413}
4414impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
4415 #[allow(deprecated)]
4416 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4417 where
4418 D: serde::Deserializer<'de>,
4419 {
4420 const FIELDS: &[&str] = &[
4421 "table_info",
4422 "tableInfo",
4423 "sink_info",
4424 "sinkInfo",
4425 "iceberg_source",
4426 "icebergSource",
4427 "if_not_exists",
4428 "ifNotExists",
4429 ];
4430
4431 #[allow(clippy::enum_variant_names)]
4432 enum GeneratedField {
4433 TableInfo,
4434 SinkInfo,
4435 IcebergSource,
4436 IfNotExists,
4437 }
4438 impl<'de> serde::Deserialize<'de> for GeneratedField {
4439 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4440 where
4441 D: serde::Deserializer<'de>,
4442 {
4443 struct GeneratedVisitor;
4444
4445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4446 type Value = GeneratedField;
4447
4448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4449 write!(formatter, "expected one of: {:?}", &FIELDS)
4450 }
4451
4452 #[allow(unused_variables)]
4453 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4454 where
4455 E: serde::de::Error,
4456 {
4457 match value {
4458 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
4459 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
4460 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
4461 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4462 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4463 }
4464 }
4465 }
4466 deserializer.deserialize_identifier(GeneratedVisitor)
4467 }
4468 }
4469 struct GeneratedVisitor;
4470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4471 type Value = CreateIcebergTableRequest;
4472
4473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4474 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
4475 }
4476
4477 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
4478 where
4479 V: serde::de::MapAccess<'de>,
4480 {
4481 let mut table_info__ = None;
4482 let mut sink_info__ = None;
4483 let mut iceberg_source__ = None;
4484 let mut if_not_exists__ = None;
4485 while let Some(k) = map_.next_key()? {
4486 match k {
4487 GeneratedField::TableInfo => {
4488 if table_info__.is_some() {
4489 return Err(serde::de::Error::duplicate_field("tableInfo"));
4490 }
4491 table_info__ = map_.next_value()?;
4492 }
4493 GeneratedField::SinkInfo => {
4494 if sink_info__.is_some() {
4495 return Err(serde::de::Error::duplicate_field("sinkInfo"));
4496 }
4497 sink_info__ = map_.next_value()?;
4498 }
4499 GeneratedField::IcebergSource => {
4500 if iceberg_source__.is_some() {
4501 return Err(serde::de::Error::duplicate_field("icebergSource"));
4502 }
4503 iceberg_source__ = map_.next_value()?;
4504 }
4505 GeneratedField::IfNotExists => {
4506 if if_not_exists__.is_some() {
4507 return Err(serde::de::Error::duplicate_field("ifNotExists"));
4508 }
4509 if_not_exists__ = Some(map_.next_value()?);
4510 }
4511 }
4512 }
4513 Ok(CreateIcebergTableRequest {
4514 table_info: table_info__,
4515 sink_info: sink_info__,
4516 iceberg_source: iceberg_source__,
4517 if_not_exists: if_not_exists__.unwrap_or_default(),
4518 })
4519 }
4520 }
4521 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
4522 }
4523}
4524impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
4525 #[allow(deprecated)]
4526 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4527 where
4528 S: serde::Serializer,
4529 {
4530 use serde::ser::SerializeStruct;
4531 let mut len = 0;
4532 if self.sink.is_some() {
4533 len += 1;
4534 }
4535 if self.fragment_graph.is_some() {
4536 len += 1;
4537 }
4538 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
4539 if let Some(v) = self.sink.as_ref() {
4540 struct_ser.serialize_field("sink", v)?;
4541 }
4542 if let Some(v) = self.fragment_graph.as_ref() {
4543 struct_ser.serialize_field("fragmentGraph", v)?;
4544 }
4545 struct_ser.end()
4546 }
4547}
4548impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
4549 #[allow(deprecated)]
4550 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4551 where
4552 D: serde::Deserializer<'de>,
4553 {
4554 const FIELDS: &[&str] = &[
4555 "sink",
4556 "fragment_graph",
4557 "fragmentGraph",
4558 ];
4559
4560 #[allow(clippy::enum_variant_names)]
4561 enum GeneratedField {
4562 Sink,
4563 FragmentGraph,
4564 }
4565 impl<'de> serde::Deserialize<'de> for GeneratedField {
4566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4567 where
4568 D: serde::Deserializer<'de>,
4569 {
4570 struct GeneratedVisitor;
4571
4572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4573 type Value = GeneratedField;
4574
4575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4576 write!(formatter, "expected one of: {:?}", &FIELDS)
4577 }
4578
4579 #[allow(unused_variables)]
4580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4581 where
4582 E: serde::de::Error,
4583 {
4584 match value {
4585 "sink" => Ok(GeneratedField::Sink),
4586 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4587 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4588 }
4589 }
4590 }
4591 deserializer.deserialize_identifier(GeneratedVisitor)
4592 }
4593 }
4594 struct GeneratedVisitor;
4595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4596 type Value = create_iceberg_table_request::SinkJobInfo;
4597
4598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4599 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
4600 }
4601
4602 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
4603 where
4604 V: serde::de::MapAccess<'de>,
4605 {
4606 let mut sink__ = None;
4607 let mut fragment_graph__ = None;
4608 while let Some(k) = map_.next_key()? {
4609 match k {
4610 GeneratedField::Sink => {
4611 if sink__.is_some() {
4612 return Err(serde::de::Error::duplicate_field("sink"));
4613 }
4614 sink__ = map_.next_value()?;
4615 }
4616 GeneratedField::FragmentGraph => {
4617 if fragment_graph__.is_some() {
4618 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4619 }
4620 fragment_graph__ = map_.next_value()?;
4621 }
4622 }
4623 }
4624 Ok(create_iceberg_table_request::SinkJobInfo {
4625 sink: sink__,
4626 fragment_graph: fragment_graph__,
4627 })
4628 }
4629 }
4630 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
4631 }
4632}
4633impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
4634 #[allow(deprecated)]
4635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4636 where
4637 S: serde::Serializer,
4638 {
4639 use serde::ser::SerializeStruct;
4640 let mut len = 0;
4641 if self.source.is_some() {
4642 len += 1;
4643 }
4644 if self.table.is_some() {
4645 len += 1;
4646 }
4647 if self.fragment_graph.is_some() {
4648 len += 1;
4649 }
4650 if self.job_type != 0 {
4651 len += 1;
4652 }
4653 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
4654 if let Some(v) = self.source.as_ref() {
4655 struct_ser.serialize_field("source", v)?;
4656 }
4657 if let Some(v) = self.table.as_ref() {
4658 struct_ser.serialize_field("table", v)?;
4659 }
4660 if let Some(v) = self.fragment_graph.as_ref() {
4661 struct_ser.serialize_field("fragmentGraph", v)?;
4662 }
4663 if self.job_type != 0 {
4664 let v = TableJobType::try_from(self.job_type)
4665 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
4666 struct_ser.serialize_field("jobType", &v)?;
4667 }
4668 struct_ser.end()
4669 }
4670}
4671impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
4672 #[allow(deprecated)]
4673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4674 where
4675 D: serde::Deserializer<'de>,
4676 {
4677 const FIELDS: &[&str] = &[
4678 "source",
4679 "table",
4680 "fragment_graph",
4681 "fragmentGraph",
4682 "job_type",
4683 "jobType",
4684 ];
4685
4686 #[allow(clippy::enum_variant_names)]
4687 enum GeneratedField {
4688 Source,
4689 Table,
4690 FragmentGraph,
4691 JobType,
4692 }
4693 impl<'de> serde::Deserialize<'de> for GeneratedField {
4694 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4695 where
4696 D: serde::Deserializer<'de>,
4697 {
4698 struct GeneratedVisitor;
4699
4700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4701 type Value = GeneratedField;
4702
4703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4704 write!(formatter, "expected one of: {:?}", &FIELDS)
4705 }
4706
4707 #[allow(unused_variables)]
4708 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4709 where
4710 E: serde::de::Error,
4711 {
4712 match value {
4713 "source" => Ok(GeneratedField::Source),
4714 "table" => Ok(GeneratedField::Table),
4715 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4716 "jobType" | "job_type" => Ok(GeneratedField::JobType),
4717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4718 }
4719 }
4720 }
4721 deserializer.deserialize_identifier(GeneratedVisitor)
4722 }
4723 }
4724 struct GeneratedVisitor;
4725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4726 type Value = create_iceberg_table_request::TableJobInfo;
4727
4728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4729 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
4730 }
4731
4732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
4733 where
4734 V: serde::de::MapAccess<'de>,
4735 {
4736 let mut source__ = None;
4737 let mut table__ = None;
4738 let mut fragment_graph__ = None;
4739 let mut job_type__ = None;
4740 while let Some(k) = map_.next_key()? {
4741 match k {
4742 GeneratedField::Source => {
4743 if source__.is_some() {
4744 return Err(serde::de::Error::duplicate_field("source"));
4745 }
4746 source__ = map_.next_value()?;
4747 }
4748 GeneratedField::Table => {
4749 if table__.is_some() {
4750 return Err(serde::de::Error::duplicate_field("table"));
4751 }
4752 table__ = map_.next_value()?;
4753 }
4754 GeneratedField::FragmentGraph => {
4755 if fragment_graph__.is_some() {
4756 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4757 }
4758 fragment_graph__ = map_.next_value()?;
4759 }
4760 GeneratedField::JobType => {
4761 if job_type__.is_some() {
4762 return Err(serde::de::Error::duplicate_field("jobType"));
4763 }
4764 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
4765 }
4766 }
4767 }
4768 Ok(create_iceberg_table_request::TableJobInfo {
4769 source: source__,
4770 table: table__,
4771 fragment_graph: fragment_graph__,
4772 job_type: job_type__.unwrap_or_default(),
4773 })
4774 }
4775 }
4776 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
4777 }
4778}
4779impl serde::Serialize for CreateIcebergTableResponse {
4780 #[allow(deprecated)]
4781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4782 where
4783 S: serde::Serializer,
4784 {
4785 use serde::ser::SerializeStruct;
4786 let mut len = 0;
4787 if self.status.is_some() {
4788 len += 1;
4789 }
4790 if self.version.is_some() {
4791 len += 1;
4792 }
4793 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
4794 if let Some(v) = self.status.as_ref() {
4795 struct_ser.serialize_field("status", v)?;
4796 }
4797 if let Some(v) = self.version.as_ref() {
4798 struct_ser.serialize_field("version", v)?;
4799 }
4800 struct_ser.end()
4801 }
4802}
4803impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
4804 #[allow(deprecated)]
4805 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4806 where
4807 D: serde::Deserializer<'de>,
4808 {
4809 const FIELDS: &[&str] = &[
4810 "status",
4811 "version",
4812 ];
4813
4814 #[allow(clippy::enum_variant_names)]
4815 enum GeneratedField {
4816 Status,
4817 Version,
4818 }
4819 impl<'de> serde::Deserialize<'de> for GeneratedField {
4820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4821 where
4822 D: serde::Deserializer<'de>,
4823 {
4824 struct GeneratedVisitor;
4825
4826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4827 type Value = GeneratedField;
4828
4829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4830 write!(formatter, "expected one of: {:?}", &FIELDS)
4831 }
4832
4833 #[allow(unused_variables)]
4834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4835 where
4836 E: serde::de::Error,
4837 {
4838 match value {
4839 "status" => Ok(GeneratedField::Status),
4840 "version" => Ok(GeneratedField::Version),
4841 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4842 }
4843 }
4844 }
4845 deserializer.deserialize_identifier(GeneratedVisitor)
4846 }
4847 }
4848 struct GeneratedVisitor;
4849 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4850 type Value = CreateIcebergTableResponse;
4851
4852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4853 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
4854 }
4855
4856 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
4857 where
4858 V: serde::de::MapAccess<'de>,
4859 {
4860 let mut status__ = None;
4861 let mut version__ = None;
4862 while let Some(k) = map_.next_key()? {
4863 match k {
4864 GeneratedField::Status => {
4865 if status__.is_some() {
4866 return Err(serde::de::Error::duplicate_field("status"));
4867 }
4868 status__ = map_.next_value()?;
4869 }
4870 GeneratedField::Version => {
4871 if version__.is_some() {
4872 return Err(serde::de::Error::duplicate_field("version"));
4873 }
4874 version__ = map_.next_value()?;
4875 }
4876 }
4877 }
4878 Ok(CreateIcebergTableResponse {
4879 status: status__,
4880 version: version__,
4881 })
4882 }
4883 }
4884 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
4885 }
4886}
4887impl serde::Serialize for CreateIndexRequest {
4888 #[allow(deprecated)]
4889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4890 where
4891 S: serde::Serializer,
4892 {
4893 use serde::ser::SerializeStruct;
4894 let mut len = 0;
4895 if self.index.is_some() {
4896 len += 1;
4897 }
4898 if self.index_table.is_some() {
4899 len += 1;
4900 }
4901 if self.fragment_graph.is_some() {
4902 len += 1;
4903 }
4904 if self.if_not_exists {
4905 len += 1;
4906 }
4907 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
4908 if let Some(v) = self.index.as_ref() {
4909 struct_ser.serialize_field("index", v)?;
4910 }
4911 if let Some(v) = self.index_table.as_ref() {
4912 struct_ser.serialize_field("indexTable", v)?;
4913 }
4914 if let Some(v) = self.fragment_graph.as_ref() {
4915 struct_ser.serialize_field("fragmentGraph", v)?;
4916 }
4917 if self.if_not_exists {
4918 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4919 }
4920 struct_ser.end()
4921 }
4922}
4923impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
4924 #[allow(deprecated)]
4925 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4926 where
4927 D: serde::Deserializer<'de>,
4928 {
4929 const FIELDS: &[&str] = &[
4930 "index",
4931 "index_table",
4932 "indexTable",
4933 "fragment_graph",
4934 "fragmentGraph",
4935 "if_not_exists",
4936 "ifNotExists",
4937 ];
4938
4939 #[allow(clippy::enum_variant_names)]
4940 enum GeneratedField {
4941 Index,
4942 IndexTable,
4943 FragmentGraph,
4944 IfNotExists,
4945 }
4946 impl<'de> serde::Deserialize<'de> for GeneratedField {
4947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4948 where
4949 D: serde::Deserializer<'de>,
4950 {
4951 struct GeneratedVisitor;
4952
4953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4954 type Value = GeneratedField;
4955
4956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4957 write!(formatter, "expected one of: {:?}", &FIELDS)
4958 }
4959
4960 #[allow(unused_variables)]
4961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4962 where
4963 E: serde::de::Error,
4964 {
4965 match value {
4966 "index" => Ok(GeneratedField::Index),
4967 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
4968 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4969 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4971 }
4972 }
4973 }
4974 deserializer.deserialize_identifier(GeneratedVisitor)
4975 }
4976 }
4977 struct GeneratedVisitor;
4978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4979 type Value = CreateIndexRequest;
4980
4981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4982 formatter.write_str("struct ddl_service.CreateIndexRequest")
4983 }
4984
4985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
4986 where
4987 V: serde::de::MapAccess<'de>,
4988 {
4989 let mut index__ = None;
4990 let mut index_table__ = None;
4991 let mut fragment_graph__ = None;
4992 let mut if_not_exists__ = None;
4993 while let Some(k) = map_.next_key()? {
4994 match k {
4995 GeneratedField::Index => {
4996 if index__.is_some() {
4997 return Err(serde::de::Error::duplicate_field("index"));
4998 }
4999 index__ = map_.next_value()?;
5000 }
5001 GeneratedField::IndexTable => {
5002 if index_table__.is_some() {
5003 return Err(serde::de::Error::duplicate_field("indexTable"));
5004 }
5005 index_table__ = map_.next_value()?;
5006 }
5007 GeneratedField::FragmentGraph => {
5008 if fragment_graph__.is_some() {
5009 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5010 }
5011 fragment_graph__ = map_.next_value()?;
5012 }
5013 GeneratedField::IfNotExists => {
5014 if if_not_exists__.is_some() {
5015 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5016 }
5017 if_not_exists__ = Some(map_.next_value()?);
5018 }
5019 }
5020 }
5021 Ok(CreateIndexRequest {
5022 index: index__,
5023 index_table: index_table__,
5024 fragment_graph: fragment_graph__,
5025 if_not_exists: if_not_exists__.unwrap_or_default(),
5026 })
5027 }
5028 }
5029 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
5030 }
5031}
5032impl serde::Serialize for CreateIndexResponse {
5033 #[allow(deprecated)]
5034 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5035 where
5036 S: serde::Serializer,
5037 {
5038 use serde::ser::SerializeStruct;
5039 let mut len = 0;
5040 if self.status.is_some() {
5041 len += 1;
5042 }
5043 if self.version.is_some() {
5044 len += 1;
5045 }
5046 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
5047 if let Some(v) = self.status.as_ref() {
5048 struct_ser.serialize_field("status", v)?;
5049 }
5050 if let Some(v) = self.version.as_ref() {
5051 struct_ser.serialize_field("version", v)?;
5052 }
5053 struct_ser.end()
5054 }
5055}
5056impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
5057 #[allow(deprecated)]
5058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5059 where
5060 D: serde::Deserializer<'de>,
5061 {
5062 const FIELDS: &[&str] = &[
5063 "status",
5064 "version",
5065 ];
5066
5067 #[allow(clippy::enum_variant_names)]
5068 enum GeneratedField {
5069 Status,
5070 Version,
5071 }
5072 impl<'de> serde::Deserialize<'de> for GeneratedField {
5073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5074 where
5075 D: serde::Deserializer<'de>,
5076 {
5077 struct GeneratedVisitor;
5078
5079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5080 type Value = GeneratedField;
5081
5082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5083 write!(formatter, "expected one of: {:?}", &FIELDS)
5084 }
5085
5086 #[allow(unused_variables)]
5087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5088 where
5089 E: serde::de::Error,
5090 {
5091 match value {
5092 "status" => Ok(GeneratedField::Status),
5093 "version" => Ok(GeneratedField::Version),
5094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5095 }
5096 }
5097 }
5098 deserializer.deserialize_identifier(GeneratedVisitor)
5099 }
5100 }
5101 struct GeneratedVisitor;
5102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5103 type Value = CreateIndexResponse;
5104
5105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5106 formatter.write_str("struct ddl_service.CreateIndexResponse")
5107 }
5108
5109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
5110 where
5111 V: serde::de::MapAccess<'de>,
5112 {
5113 let mut status__ = None;
5114 let mut version__ = None;
5115 while let Some(k) = map_.next_key()? {
5116 match k {
5117 GeneratedField::Status => {
5118 if status__.is_some() {
5119 return Err(serde::de::Error::duplicate_field("status"));
5120 }
5121 status__ = map_.next_value()?;
5122 }
5123 GeneratedField::Version => {
5124 if version__.is_some() {
5125 return Err(serde::de::Error::duplicate_field("version"));
5126 }
5127 version__ = map_.next_value()?;
5128 }
5129 }
5130 }
5131 Ok(CreateIndexResponse {
5132 status: status__,
5133 version: version__,
5134 })
5135 }
5136 }
5137 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
5138 }
5139}
5140impl serde::Serialize for CreateMaterializedViewRequest {
5141 #[allow(deprecated)]
5142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5143 where
5144 S: serde::Serializer,
5145 {
5146 use serde::ser::SerializeStruct;
5147 let mut len = 0;
5148 if self.materialized_view.is_some() {
5149 len += 1;
5150 }
5151 if self.fragment_graph.is_some() {
5152 len += 1;
5153 }
5154 if self.backfill != 0 {
5155 len += 1;
5156 }
5157 if !self.dependencies.is_empty() {
5158 len += 1;
5159 }
5160 if self.specific_resource_group.is_some() {
5161 len += 1;
5162 }
5163 if self.if_not_exists {
5164 len += 1;
5165 }
5166 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
5167 if let Some(v) = self.materialized_view.as_ref() {
5168 struct_ser.serialize_field("materializedView", v)?;
5169 }
5170 if let Some(v) = self.fragment_graph.as_ref() {
5171 struct_ser.serialize_field("fragmentGraph", v)?;
5172 }
5173 if self.backfill != 0 {
5174 let v = create_materialized_view_request::BackfillType::try_from(self.backfill)
5175 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill)))?;
5176 struct_ser.serialize_field("backfill", &v)?;
5177 }
5178 if !self.dependencies.is_empty() {
5179 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5180 }
5181 if let Some(v) = self.specific_resource_group.as_ref() {
5182 struct_ser.serialize_field("specificResourceGroup", v)?;
5183 }
5184 if self.if_not_exists {
5185 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5186 }
5187 struct_ser.end()
5188 }
5189}
5190impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
5191 #[allow(deprecated)]
5192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5193 where
5194 D: serde::Deserializer<'de>,
5195 {
5196 const FIELDS: &[&str] = &[
5197 "materialized_view",
5198 "materializedView",
5199 "fragment_graph",
5200 "fragmentGraph",
5201 "backfill",
5202 "dependencies",
5203 "specific_resource_group",
5204 "specificResourceGroup",
5205 "if_not_exists",
5206 "ifNotExists",
5207 ];
5208
5209 #[allow(clippy::enum_variant_names)]
5210 enum GeneratedField {
5211 MaterializedView,
5212 FragmentGraph,
5213 Backfill,
5214 Dependencies,
5215 SpecificResourceGroup,
5216 IfNotExists,
5217 }
5218 impl<'de> serde::Deserialize<'de> for GeneratedField {
5219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5220 where
5221 D: serde::Deserializer<'de>,
5222 {
5223 struct GeneratedVisitor;
5224
5225 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5226 type Value = GeneratedField;
5227
5228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5229 write!(formatter, "expected one of: {:?}", &FIELDS)
5230 }
5231
5232 #[allow(unused_variables)]
5233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5234 where
5235 E: serde::de::Error,
5236 {
5237 match value {
5238 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5239 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5240 "backfill" => Ok(GeneratedField::Backfill),
5241 "dependencies" => Ok(GeneratedField::Dependencies),
5242 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
5243 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5244 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5245 }
5246 }
5247 }
5248 deserializer.deserialize_identifier(GeneratedVisitor)
5249 }
5250 }
5251 struct GeneratedVisitor;
5252 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5253 type Value = CreateMaterializedViewRequest;
5254
5255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5256 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
5257 }
5258
5259 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
5260 where
5261 V: serde::de::MapAccess<'de>,
5262 {
5263 let mut materialized_view__ = None;
5264 let mut fragment_graph__ = None;
5265 let mut backfill__ = None;
5266 let mut dependencies__ = None;
5267 let mut specific_resource_group__ = None;
5268 let mut if_not_exists__ = None;
5269 while let Some(k) = map_.next_key()? {
5270 match k {
5271 GeneratedField::MaterializedView => {
5272 if materialized_view__.is_some() {
5273 return Err(serde::de::Error::duplicate_field("materializedView"));
5274 }
5275 materialized_view__ = map_.next_value()?;
5276 }
5277 GeneratedField::FragmentGraph => {
5278 if fragment_graph__.is_some() {
5279 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5280 }
5281 fragment_graph__ = map_.next_value()?;
5282 }
5283 GeneratedField::Backfill => {
5284 if backfill__.is_some() {
5285 return Err(serde::de::Error::duplicate_field("backfill"));
5286 }
5287 backfill__ = Some(map_.next_value::<create_materialized_view_request::BackfillType>()? as i32);
5288 }
5289 GeneratedField::Dependencies => {
5290 if dependencies__.is_some() {
5291 return Err(serde::de::Error::duplicate_field("dependencies"));
5292 }
5293 dependencies__ =
5294 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5295 .into_iter().map(|x| x.0).collect())
5296 ;
5297 }
5298 GeneratedField::SpecificResourceGroup => {
5299 if specific_resource_group__.is_some() {
5300 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
5301 }
5302 specific_resource_group__ = map_.next_value()?;
5303 }
5304 GeneratedField::IfNotExists => {
5305 if if_not_exists__.is_some() {
5306 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5307 }
5308 if_not_exists__ = Some(map_.next_value()?);
5309 }
5310 }
5311 }
5312 Ok(CreateMaterializedViewRequest {
5313 materialized_view: materialized_view__,
5314 fragment_graph: fragment_graph__,
5315 backfill: backfill__.unwrap_or_default(),
5316 dependencies: dependencies__.unwrap_or_default(),
5317 specific_resource_group: specific_resource_group__,
5318 if_not_exists: if_not_exists__.unwrap_or_default(),
5319 })
5320 }
5321 }
5322 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
5323 }
5324}
5325impl serde::Serialize for create_materialized_view_request::BackfillType {
5326 #[allow(deprecated)]
5327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5328 where
5329 S: serde::Serializer,
5330 {
5331 let variant = match self {
5332 Self::Unspecified => "UNSPECIFIED",
5333 Self::Regular => "REGULAR",
5334 Self::Serverless => "SERVERLESS",
5335 };
5336 serializer.serialize_str(variant)
5337 }
5338}
5339impl<'de> serde::Deserialize<'de> for create_materialized_view_request::BackfillType {
5340 #[allow(deprecated)]
5341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5342 where
5343 D: serde::Deserializer<'de>,
5344 {
5345 const FIELDS: &[&str] = &[
5346 "UNSPECIFIED",
5347 "REGULAR",
5348 "SERVERLESS",
5349 ];
5350
5351 struct GeneratedVisitor;
5352
5353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5354 type Value = create_materialized_view_request::BackfillType;
5355
5356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5357 write!(formatter, "expected one of: {:?}", &FIELDS)
5358 }
5359
5360 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5361 where
5362 E: serde::de::Error,
5363 {
5364 i32::try_from(v)
5365 .ok()
5366 .and_then(|x| x.try_into().ok())
5367 .ok_or_else(|| {
5368 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5369 })
5370 }
5371
5372 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5373 where
5374 E: serde::de::Error,
5375 {
5376 i32::try_from(v)
5377 .ok()
5378 .and_then(|x| x.try_into().ok())
5379 .ok_or_else(|| {
5380 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5381 })
5382 }
5383
5384 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5385 where
5386 E: serde::de::Error,
5387 {
5388 match value {
5389 "UNSPECIFIED" => Ok(create_materialized_view_request::BackfillType::Unspecified),
5390 "REGULAR" => Ok(create_materialized_view_request::BackfillType::Regular),
5391 "SERVERLESS" => Ok(create_materialized_view_request::BackfillType::Serverless),
5392 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5393 }
5394 }
5395 }
5396 deserializer.deserialize_any(GeneratedVisitor)
5397 }
5398}
5399impl serde::Serialize for CreateMaterializedViewResponse {
5400 #[allow(deprecated)]
5401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5402 where
5403 S: serde::Serializer,
5404 {
5405 use serde::ser::SerializeStruct;
5406 let mut len = 0;
5407 if self.status.is_some() {
5408 len += 1;
5409 }
5410 if self.version.is_some() {
5411 len += 1;
5412 }
5413 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
5414 if let Some(v) = self.status.as_ref() {
5415 struct_ser.serialize_field("status", v)?;
5416 }
5417 if let Some(v) = self.version.as_ref() {
5418 struct_ser.serialize_field("version", v)?;
5419 }
5420 struct_ser.end()
5421 }
5422}
5423impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
5424 #[allow(deprecated)]
5425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5426 where
5427 D: serde::Deserializer<'de>,
5428 {
5429 const FIELDS: &[&str] = &[
5430 "status",
5431 "version",
5432 ];
5433
5434 #[allow(clippy::enum_variant_names)]
5435 enum GeneratedField {
5436 Status,
5437 Version,
5438 }
5439 impl<'de> serde::Deserialize<'de> for GeneratedField {
5440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5441 where
5442 D: serde::Deserializer<'de>,
5443 {
5444 struct GeneratedVisitor;
5445
5446 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5447 type Value = GeneratedField;
5448
5449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5450 write!(formatter, "expected one of: {:?}", &FIELDS)
5451 }
5452
5453 #[allow(unused_variables)]
5454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5455 where
5456 E: serde::de::Error,
5457 {
5458 match value {
5459 "status" => Ok(GeneratedField::Status),
5460 "version" => Ok(GeneratedField::Version),
5461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5462 }
5463 }
5464 }
5465 deserializer.deserialize_identifier(GeneratedVisitor)
5466 }
5467 }
5468 struct GeneratedVisitor;
5469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5470 type Value = CreateMaterializedViewResponse;
5471
5472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5473 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
5474 }
5475
5476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
5477 where
5478 V: serde::de::MapAccess<'de>,
5479 {
5480 let mut status__ = None;
5481 let mut version__ = None;
5482 while let Some(k) = map_.next_key()? {
5483 match k {
5484 GeneratedField::Status => {
5485 if status__.is_some() {
5486 return Err(serde::de::Error::duplicate_field("status"));
5487 }
5488 status__ = map_.next_value()?;
5489 }
5490 GeneratedField::Version => {
5491 if version__.is_some() {
5492 return Err(serde::de::Error::duplicate_field("version"));
5493 }
5494 version__ = map_.next_value()?;
5495 }
5496 }
5497 }
5498 Ok(CreateMaterializedViewResponse {
5499 status: status__,
5500 version: version__,
5501 })
5502 }
5503 }
5504 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
5505 }
5506}
5507impl serde::Serialize for CreateSchemaRequest {
5508 #[allow(deprecated)]
5509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5510 where
5511 S: serde::Serializer,
5512 {
5513 use serde::ser::SerializeStruct;
5514 let mut len = 0;
5515 if self.schema.is_some() {
5516 len += 1;
5517 }
5518 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
5519 if let Some(v) = self.schema.as_ref() {
5520 struct_ser.serialize_field("schema", v)?;
5521 }
5522 struct_ser.end()
5523 }
5524}
5525impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
5526 #[allow(deprecated)]
5527 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5528 where
5529 D: serde::Deserializer<'de>,
5530 {
5531 const FIELDS: &[&str] = &[
5532 "schema",
5533 ];
5534
5535 #[allow(clippy::enum_variant_names)]
5536 enum GeneratedField {
5537 Schema,
5538 }
5539 impl<'de> serde::Deserialize<'de> for GeneratedField {
5540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5541 where
5542 D: serde::Deserializer<'de>,
5543 {
5544 struct GeneratedVisitor;
5545
5546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5547 type Value = GeneratedField;
5548
5549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5550 write!(formatter, "expected one of: {:?}", &FIELDS)
5551 }
5552
5553 #[allow(unused_variables)]
5554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5555 where
5556 E: serde::de::Error,
5557 {
5558 match value {
5559 "schema" => Ok(GeneratedField::Schema),
5560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5561 }
5562 }
5563 }
5564 deserializer.deserialize_identifier(GeneratedVisitor)
5565 }
5566 }
5567 struct GeneratedVisitor;
5568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5569 type Value = CreateSchemaRequest;
5570
5571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5572 formatter.write_str("struct ddl_service.CreateSchemaRequest")
5573 }
5574
5575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
5576 where
5577 V: serde::de::MapAccess<'de>,
5578 {
5579 let mut schema__ = None;
5580 while let Some(k) = map_.next_key()? {
5581 match k {
5582 GeneratedField::Schema => {
5583 if schema__.is_some() {
5584 return Err(serde::de::Error::duplicate_field("schema"));
5585 }
5586 schema__ = map_.next_value()?;
5587 }
5588 }
5589 }
5590 Ok(CreateSchemaRequest {
5591 schema: schema__,
5592 })
5593 }
5594 }
5595 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
5596 }
5597}
5598impl serde::Serialize for CreateSchemaResponse {
5599 #[allow(deprecated)]
5600 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5601 where
5602 S: serde::Serializer,
5603 {
5604 use serde::ser::SerializeStruct;
5605 let mut len = 0;
5606 if self.status.is_some() {
5607 len += 1;
5608 }
5609 if self.version.is_some() {
5610 len += 1;
5611 }
5612 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
5613 if let Some(v) = self.status.as_ref() {
5614 struct_ser.serialize_field("status", v)?;
5615 }
5616 if let Some(v) = self.version.as_ref() {
5617 struct_ser.serialize_field("version", v)?;
5618 }
5619 struct_ser.end()
5620 }
5621}
5622impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
5623 #[allow(deprecated)]
5624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5625 where
5626 D: serde::Deserializer<'de>,
5627 {
5628 const FIELDS: &[&str] = &[
5629 "status",
5630 "version",
5631 ];
5632
5633 #[allow(clippy::enum_variant_names)]
5634 enum GeneratedField {
5635 Status,
5636 Version,
5637 }
5638 impl<'de> serde::Deserialize<'de> for GeneratedField {
5639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5640 where
5641 D: serde::Deserializer<'de>,
5642 {
5643 struct GeneratedVisitor;
5644
5645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5646 type Value = GeneratedField;
5647
5648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5649 write!(formatter, "expected one of: {:?}", &FIELDS)
5650 }
5651
5652 #[allow(unused_variables)]
5653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5654 where
5655 E: serde::de::Error,
5656 {
5657 match value {
5658 "status" => Ok(GeneratedField::Status),
5659 "version" => Ok(GeneratedField::Version),
5660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5661 }
5662 }
5663 }
5664 deserializer.deserialize_identifier(GeneratedVisitor)
5665 }
5666 }
5667 struct GeneratedVisitor;
5668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5669 type Value = CreateSchemaResponse;
5670
5671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5672 formatter.write_str("struct ddl_service.CreateSchemaResponse")
5673 }
5674
5675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
5676 where
5677 V: serde::de::MapAccess<'de>,
5678 {
5679 let mut status__ = None;
5680 let mut version__ = None;
5681 while let Some(k) = map_.next_key()? {
5682 match k {
5683 GeneratedField::Status => {
5684 if status__.is_some() {
5685 return Err(serde::de::Error::duplicate_field("status"));
5686 }
5687 status__ = map_.next_value()?;
5688 }
5689 GeneratedField::Version => {
5690 if version__.is_some() {
5691 return Err(serde::de::Error::duplicate_field("version"));
5692 }
5693 version__ = map_.next_value()?;
5694 }
5695 }
5696 }
5697 Ok(CreateSchemaResponse {
5698 status: status__,
5699 version: version__,
5700 })
5701 }
5702 }
5703 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
5704 }
5705}
5706impl serde::Serialize for CreateSecretRequest {
5707 #[allow(deprecated)]
5708 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5709 where
5710 S: serde::Serializer,
5711 {
5712 use serde::ser::SerializeStruct;
5713 let mut len = 0;
5714 if !self.name.is_empty() {
5715 len += 1;
5716 }
5717 if !self.value.is_empty() {
5718 len += 1;
5719 }
5720 if self.database_id != 0 {
5721 len += 1;
5722 }
5723 if self.schema_id != 0 {
5724 len += 1;
5725 }
5726 if self.owner_id != 0 {
5727 len += 1;
5728 }
5729 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
5730 if !self.name.is_empty() {
5731 struct_ser.serialize_field("name", &self.name)?;
5732 }
5733 if !self.value.is_empty() {
5734 #[allow(clippy::needless_borrow)]
5735 #[allow(clippy::needless_borrows_for_generic_args)]
5736 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
5737 }
5738 if self.database_id != 0 {
5739 struct_ser.serialize_field("databaseId", &self.database_id)?;
5740 }
5741 if self.schema_id != 0 {
5742 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5743 }
5744 if self.owner_id != 0 {
5745 struct_ser.serialize_field("ownerId", &self.owner_id)?;
5746 }
5747 struct_ser.end()
5748 }
5749}
5750impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
5751 #[allow(deprecated)]
5752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5753 where
5754 D: serde::Deserializer<'de>,
5755 {
5756 const FIELDS: &[&str] = &[
5757 "name",
5758 "value",
5759 "database_id",
5760 "databaseId",
5761 "schema_id",
5762 "schemaId",
5763 "owner_id",
5764 "ownerId",
5765 ];
5766
5767 #[allow(clippy::enum_variant_names)]
5768 enum GeneratedField {
5769 Name,
5770 Value,
5771 DatabaseId,
5772 SchemaId,
5773 OwnerId,
5774 }
5775 impl<'de> serde::Deserialize<'de> for GeneratedField {
5776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5777 where
5778 D: serde::Deserializer<'de>,
5779 {
5780 struct GeneratedVisitor;
5781
5782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5783 type Value = GeneratedField;
5784
5785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5786 write!(formatter, "expected one of: {:?}", &FIELDS)
5787 }
5788
5789 #[allow(unused_variables)]
5790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5791 where
5792 E: serde::de::Error,
5793 {
5794 match value {
5795 "name" => Ok(GeneratedField::Name),
5796 "value" => Ok(GeneratedField::Value),
5797 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5798 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5799 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
5800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5801 }
5802 }
5803 }
5804 deserializer.deserialize_identifier(GeneratedVisitor)
5805 }
5806 }
5807 struct GeneratedVisitor;
5808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5809 type Value = CreateSecretRequest;
5810
5811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5812 formatter.write_str("struct ddl_service.CreateSecretRequest")
5813 }
5814
5815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
5816 where
5817 V: serde::de::MapAccess<'de>,
5818 {
5819 let mut name__ = None;
5820 let mut value__ = None;
5821 let mut database_id__ = None;
5822 let mut schema_id__ = None;
5823 let mut owner_id__ = None;
5824 while let Some(k) = map_.next_key()? {
5825 match k {
5826 GeneratedField::Name => {
5827 if name__.is_some() {
5828 return Err(serde::de::Error::duplicate_field("name"));
5829 }
5830 name__ = Some(map_.next_value()?);
5831 }
5832 GeneratedField::Value => {
5833 if value__.is_some() {
5834 return Err(serde::de::Error::duplicate_field("value"));
5835 }
5836 value__ =
5837 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
5838 ;
5839 }
5840 GeneratedField::DatabaseId => {
5841 if database_id__.is_some() {
5842 return Err(serde::de::Error::duplicate_field("databaseId"));
5843 }
5844 database_id__ =
5845 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5846 ;
5847 }
5848 GeneratedField::SchemaId => {
5849 if schema_id__.is_some() {
5850 return Err(serde::de::Error::duplicate_field("schemaId"));
5851 }
5852 schema_id__ =
5853 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5854 ;
5855 }
5856 GeneratedField::OwnerId => {
5857 if owner_id__.is_some() {
5858 return Err(serde::de::Error::duplicate_field("ownerId"));
5859 }
5860 owner_id__ =
5861 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5862 ;
5863 }
5864 }
5865 }
5866 Ok(CreateSecretRequest {
5867 name: name__.unwrap_or_default(),
5868 value: value__.unwrap_or_default(),
5869 database_id: database_id__.unwrap_or_default(),
5870 schema_id: schema_id__.unwrap_or_default(),
5871 owner_id: owner_id__.unwrap_or_default(),
5872 })
5873 }
5874 }
5875 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
5876 }
5877}
5878impl serde::Serialize for CreateSecretResponse {
5879 #[allow(deprecated)]
5880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5881 where
5882 S: serde::Serializer,
5883 {
5884 use serde::ser::SerializeStruct;
5885 let mut len = 0;
5886 if self.version.is_some() {
5887 len += 1;
5888 }
5889 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
5890 if let Some(v) = self.version.as_ref() {
5891 struct_ser.serialize_field("version", v)?;
5892 }
5893 struct_ser.end()
5894 }
5895}
5896impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
5897 #[allow(deprecated)]
5898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5899 where
5900 D: serde::Deserializer<'de>,
5901 {
5902 const FIELDS: &[&str] = &[
5903 "version",
5904 ];
5905
5906 #[allow(clippy::enum_variant_names)]
5907 enum GeneratedField {
5908 Version,
5909 }
5910 impl<'de> serde::Deserialize<'de> for GeneratedField {
5911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5912 where
5913 D: serde::Deserializer<'de>,
5914 {
5915 struct GeneratedVisitor;
5916
5917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5918 type Value = GeneratedField;
5919
5920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5921 write!(formatter, "expected one of: {:?}", &FIELDS)
5922 }
5923
5924 #[allow(unused_variables)]
5925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5926 where
5927 E: serde::de::Error,
5928 {
5929 match value {
5930 "version" => Ok(GeneratedField::Version),
5931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5932 }
5933 }
5934 }
5935 deserializer.deserialize_identifier(GeneratedVisitor)
5936 }
5937 }
5938 struct GeneratedVisitor;
5939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940 type Value = CreateSecretResponse;
5941
5942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943 formatter.write_str("struct ddl_service.CreateSecretResponse")
5944 }
5945
5946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
5947 where
5948 V: serde::de::MapAccess<'de>,
5949 {
5950 let mut version__ = None;
5951 while let Some(k) = map_.next_key()? {
5952 match k {
5953 GeneratedField::Version => {
5954 if version__.is_some() {
5955 return Err(serde::de::Error::duplicate_field("version"));
5956 }
5957 version__ = map_.next_value()?;
5958 }
5959 }
5960 }
5961 Ok(CreateSecretResponse {
5962 version: version__,
5963 })
5964 }
5965 }
5966 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
5967 }
5968}
5969impl serde::Serialize for CreateSinkRequest {
5970 #[allow(deprecated)]
5971 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5972 where
5973 S: serde::Serializer,
5974 {
5975 use serde::ser::SerializeStruct;
5976 let mut len = 0;
5977 if self.sink.is_some() {
5978 len += 1;
5979 }
5980 if self.fragment_graph.is_some() {
5981 len += 1;
5982 }
5983 if !self.dependencies.is_empty() {
5984 len += 1;
5985 }
5986 if self.if_not_exists {
5987 len += 1;
5988 }
5989 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
5990 if let Some(v) = self.sink.as_ref() {
5991 struct_ser.serialize_field("sink", v)?;
5992 }
5993 if let Some(v) = self.fragment_graph.as_ref() {
5994 struct_ser.serialize_field("fragmentGraph", v)?;
5995 }
5996 if !self.dependencies.is_empty() {
5997 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5998 }
5999 if self.if_not_exists {
6000 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6001 }
6002 struct_ser.end()
6003 }
6004}
6005impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
6006 #[allow(deprecated)]
6007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6008 where
6009 D: serde::Deserializer<'de>,
6010 {
6011 const FIELDS: &[&str] = &[
6012 "sink",
6013 "fragment_graph",
6014 "fragmentGraph",
6015 "dependencies",
6016 "if_not_exists",
6017 "ifNotExists",
6018 ];
6019
6020 #[allow(clippy::enum_variant_names)]
6021 enum GeneratedField {
6022 Sink,
6023 FragmentGraph,
6024 Dependencies,
6025 IfNotExists,
6026 }
6027 impl<'de> serde::Deserialize<'de> for GeneratedField {
6028 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6029 where
6030 D: serde::Deserializer<'de>,
6031 {
6032 struct GeneratedVisitor;
6033
6034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6035 type Value = GeneratedField;
6036
6037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6038 write!(formatter, "expected one of: {:?}", &FIELDS)
6039 }
6040
6041 #[allow(unused_variables)]
6042 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6043 where
6044 E: serde::de::Error,
6045 {
6046 match value {
6047 "sink" => Ok(GeneratedField::Sink),
6048 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6049 "dependencies" => Ok(GeneratedField::Dependencies),
6050 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6051 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6052 }
6053 }
6054 }
6055 deserializer.deserialize_identifier(GeneratedVisitor)
6056 }
6057 }
6058 struct GeneratedVisitor;
6059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6060 type Value = CreateSinkRequest;
6061
6062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6063 formatter.write_str("struct ddl_service.CreateSinkRequest")
6064 }
6065
6066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
6067 where
6068 V: serde::de::MapAccess<'de>,
6069 {
6070 let mut sink__ = None;
6071 let mut fragment_graph__ = None;
6072 let mut dependencies__ = None;
6073 let mut if_not_exists__ = None;
6074 while let Some(k) = map_.next_key()? {
6075 match k {
6076 GeneratedField::Sink => {
6077 if sink__.is_some() {
6078 return Err(serde::de::Error::duplicate_field("sink"));
6079 }
6080 sink__ = map_.next_value()?;
6081 }
6082 GeneratedField::FragmentGraph => {
6083 if fragment_graph__.is_some() {
6084 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6085 }
6086 fragment_graph__ = map_.next_value()?;
6087 }
6088 GeneratedField::Dependencies => {
6089 if dependencies__.is_some() {
6090 return Err(serde::de::Error::duplicate_field("dependencies"));
6091 }
6092 dependencies__ =
6093 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6094 .into_iter().map(|x| x.0).collect())
6095 ;
6096 }
6097 GeneratedField::IfNotExists => {
6098 if if_not_exists__.is_some() {
6099 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6100 }
6101 if_not_exists__ = Some(map_.next_value()?);
6102 }
6103 }
6104 }
6105 Ok(CreateSinkRequest {
6106 sink: sink__,
6107 fragment_graph: fragment_graph__,
6108 dependencies: dependencies__.unwrap_or_default(),
6109 if_not_exists: if_not_exists__.unwrap_or_default(),
6110 })
6111 }
6112 }
6113 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
6114 }
6115}
6116impl serde::Serialize for CreateSinkResponse {
6117 #[allow(deprecated)]
6118 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6119 where
6120 S: serde::Serializer,
6121 {
6122 use serde::ser::SerializeStruct;
6123 let mut len = 0;
6124 if self.status.is_some() {
6125 len += 1;
6126 }
6127 if self.version.is_some() {
6128 len += 1;
6129 }
6130 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
6131 if let Some(v) = self.status.as_ref() {
6132 struct_ser.serialize_field("status", v)?;
6133 }
6134 if let Some(v) = self.version.as_ref() {
6135 struct_ser.serialize_field("version", v)?;
6136 }
6137 struct_ser.end()
6138 }
6139}
6140impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
6141 #[allow(deprecated)]
6142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6143 where
6144 D: serde::Deserializer<'de>,
6145 {
6146 const FIELDS: &[&str] = &[
6147 "status",
6148 "version",
6149 ];
6150
6151 #[allow(clippy::enum_variant_names)]
6152 enum GeneratedField {
6153 Status,
6154 Version,
6155 }
6156 impl<'de> serde::Deserialize<'de> for GeneratedField {
6157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6158 where
6159 D: serde::Deserializer<'de>,
6160 {
6161 struct GeneratedVisitor;
6162
6163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6164 type Value = GeneratedField;
6165
6166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6167 write!(formatter, "expected one of: {:?}", &FIELDS)
6168 }
6169
6170 #[allow(unused_variables)]
6171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6172 where
6173 E: serde::de::Error,
6174 {
6175 match value {
6176 "status" => Ok(GeneratedField::Status),
6177 "version" => Ok(GeneratedField::Version),
6178 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6179 }
6180 }
6181 }
6182 deserializer.deserialize_identifier(GeneratedVisitor)
6183 }
6184 }
6185 struct GeneratedVisitor;
6186 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6187 type Value = CreateSinkResponse;
6188
6189 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6190 formatter.write_str("struct ddl_service.CreateSinkResponse")
6191 }
6192
6193 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
6194 where
6195 V: serde::de::MapAccess<'de>,
6196 {
6197 let mut status__ = None;
6198 let mut version__ = None;
6199 while let Some(k) = map_.next_key()? {
6200 match k {
6201 GeneratedField::Status => {
6202 if status__.is_some() {
6203 return Err(serde::de::Error::duplicate_field("status"));
6204 }
6205 status__ = map_.next_value()?;
6206 }
6207 GeneratedField::Version => {
6208 if version__.is_some() {
6209 return Err(serde::de::Error::duplicate_field("version"));
6210 }
6211 version__ = map_.next_value()?;
6212 }
6213 }
6214 }
6215 Ok(CreateSinkResponse {
6216 status: status__,
6217 version: version__,
6218 })
6219 }
6220 }
6221 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
6222 }
6223}
6224impl serde::Serialize for CreateSourceRequest {
6225 #[allow(deprecated)]
6226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6227 where
6228 S: serde::Serializer,
6229 {
6230 use serde::ser::SerializeStruct;
6231 let mut len = 0;
6232 if self.source.is_some() {
6233 len += 1;
6234 }
6235 if self.fragment_graph.is_some() {
6236 len += 1;
6237 }
6238 if self.if_not_exists {
6239 len += 1;
6240 }
6241 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
6242 if let Some(v) = self.source.as_ref() {
6243 struct_ser.serialize_field("source", v)?;
6244 }
6245 if let Some(v) = self.fragment_graph.as_ref() {
6246 struct_ser.serialize_field("fragmentGraph", v)?;
6247 }
6248 if self.if_not_exists {
6249 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6250 }
6251 struct_ser.end()
6252 }
6253}
6254impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
6255 #[allow(deprecated)]
6256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6257 where
6258 D: serde::Deserializer<'de>,
6259 {
6260 const FIELDS: &[&str] = &[
6261 "source",
6262 "fragment_graph",
6263 "fragmentGraph",
6264 "if_not_exists",
6265 "ifNotExists",
6266 ];
6267
6268 #[allow(clippy::enum_variant_names)]
6269 enum GeneratedField {
6270 Source,
6271 FragmentGraph,
6272 IfNotExists,
6273 }
6274 impl<'de> serde::Deserialize<'de> for GeneratedField {
6275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6276 where
6277 D: serde::Deserializer<'de>,
6278 {
6279 struct GeneratedVisitor;
6280
6281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6282 type Value = GeneratedField;
6283
6284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6285 write!(formatter, "expected one of: {:?}", &FIELDS)
6286 }
6287
6288 #[allow(unused_variables)]
6289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6290 where
6291 E: serde::de::Error,
6292 {
6293 match value {
6294 "source" => Ok(GeneratedField::Source),
6295 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6296 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6297 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6298 }
6299 }
6300 }
6301 deserializer.deserialize_identifier(GeneratedVisitor)
6302 }
6303 }
6304 struct GeneratedVisitor;
6305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6306 type Value = CreateSourceRequest;
6307
6308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6309 formatter.write_str("struct ddl_service.CreateSourceRequest")
6310 }
6311
6312 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
6313 where
6314 V: serde::de::MapAccess<'de>,
6315 {
6316 let mut source__ = None;
6317 let mut fragment_graph__ = None;
6318 let mut if_not_exists__ = None;
6319 while let Some(k) = map_.next_key()? {
6320 match k {
6321 GeneratedField::Source => {
6322 if source__.is_some() {
6323 return Err(serde::de::Error::duplicate_field("source"));
6324 }
6325 source__ = map_.next_value()?;
6326 }
6327 GeneratedField::FragmentGraph => {
6328 if fragment_graph__.is_some() {
6329 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6330 }
6331 fragment_graph__ = map_.next_value()?;
6332 }
6333 GeneratedField::IfNotExists => {
6334 if if_not_exists__.is_some() {
6335 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6336 }
6337 if_not_exists__ = Some(map_.next_value()?);
6338 }
6339 }
6340 }
6341 Ok(CreateSourceRequest {
6342 source: source__,
6343 fragment_graph: fragment_graph__,
6344 if_not_exists: if_not_exists__.unwrap_or_default(),
6345 })
6346 }
6347 }
6348 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
6349 }
6350}
6351impl serde::Serialize for CreateSourceResponse {
6352 #[allow(deprecated)]
6353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6354 where
6355 S: serde::Serializer,
6356 {
6357 use serde::ser::SerializeStruct;
6358 let mut len = 0;
6359 if self.status.is_some() {
6360 len += 1;
6361 }
6362 if self.version.is_some() {
6363 len += 1;
6364 }
6365 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
6366 if let Some(v) = self.status.as_ref() {
6367 struct_ser.serialize_field("status", v)?;
6368 }
6369 if let Some(v) = self.version.as_ref() {
6370 struct_ser.serialize_field("version", v)?;
6371 }
6372 struct_ser.end()
6373 }
6374}
6375impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
6376 #[allow(deprecated)]
6377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6378 where
6379 D: serde::Deserializer<'de>,
6380 {
6381 const FIELDS: &[&str] = &[
6382 "status",
6383 "version",
6384 ];
6385
6386 #[allow(clippy::enum_variant_names)]
6387 enum GeneratedField {
6388 Status,
6389 Version,
6390 }
6391 impl<'de> serde::Deserialize<'de> for GeneratedField {
6392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6393 where
6394 D: serde::Deserializer<'de>,
6395 {
6396 struct GeneratedVisitor;
6397
6398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6399 type Value = GeneratedField;
6400
6401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6402 write!(formatter, "expected one of: {:?}", &FIELDS)
6403 }
6404
6405 #[allow(unused_variables)]
6406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6407 where
6408 E: serde::de::Error,
6409 {
6410 match value {
6411 "status" => Ok(GeneratedField::Status),
6412 "version" => Ok(GeneratedField::Version),
6413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6414 }
6415 }
6416 }
6417 deserializer.deserialize_identifier(GeneratedVisitor)
6418 }
6419 }
6420 struct GeneratedVisitor;
6421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6422 type Value = CreateSourceResponse;
6423
6424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6425 formatter.write_str("struct ddl_service.CreateSourceResponse")
6426 }
6427
6428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
6429 where
6430 V: serde::de::MapAccess<'de>,
6431 {
6432 let mut status__ = None;
6433 let mut version__ = None;
6434 while let Some(k) = map_.next_key()? {
6435 match k {
6436 GeneratedField::Status => {
6437 if status__.is_some() {
6438 return Err(serde::de::Error::duplicate_field("status"));
6439 }
6440 status__ = map_.next_value()?;
6441 }
6442 GeneratedField::Version => {
6443 if version__.is_some() {
6444 return Err(serde::de::Error::duplicate_field("version"));
6445 }
6446 version__ = map_.next_value()?;
6447 }
6448 }
6449 }
6450 Ok(CreateSourceResponse {
6451 status: status__,
6452 version: version__,
6453 })
6454 }
6455 }
6456 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
6457 }
6458}
6459impl serde::Serialize for CreateSubscriptionRequest {
6460 #[allow(deprecated)]
6461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6462 where
6463 S: serde::Serializer,
6464 {
6465 use serde::ser::SerializeStruct;
6466 let mut len = 0;
6467 if self.subscription.is_some() {
6468 len += 1;
6469 }
6470 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
6471 if let Some(v) = self.subscription.as_ref() {
6472 struct_ser.serialize_field("subscription", v)?;
6473 }
6474 struct_ser.end()
6475 }
6476}
6477impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
6478 #[allow(deprecated)]
6479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6480 where
6481 D: serde::Deserializer<'de>,
6482 {
6483 const FIELDS: &[&str] = &[
6484 "subscription",
6485 ];
6486
6487 #[allow(clippy::enum_variant_names)]
6488 enum GeneratedField {
6489 Subscription,
6490 }
6491 impl<'de> serde::Deserialize<'de> for GeneratedField {
6492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6493 where
6494 D: serde::Deserializer<'de>,
6495 {
6496 struct GeneratedVisitor;
6497
6498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6499 type Value = GeneratedField;
6500
6501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6502 write!(formatter, "expected one of: {:?}", &FIELDS)
6503 }
6504
6505 #[allow(unused_variables)]
6506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6507 where
6508 E: serde::de::Error,
6509 {
6510 match value {
6511 "subscription" => Ok(GeneratedField::Subscription),
6512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6513 }
6514 }
6515 }
6516 deserializer.deserialize_identifier(GeneratedVisitor)
6517 }
6518 }
6519 struct GeneratedVisitor;
6520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6521 type Value = CreateSubscriptionRequest;
6522
6523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
6525 }
6526
6527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
6528 where
6529 V: serde::de::MapAccess<'de>,
6530 {
6531 let mut subscription__ = None;
6532 while let Some(k) = map_.next_key()? {
6533 match k {
6534 GeneratedField::Subscription => {
6535 if subscription__.is_some() {
6536 return Err(serde::de::Error::duplicate_field("subscription"));
6537 }
6538 subscription__ = map_.next_value()?;
6539 }
6540 }
6541 }
6542 Ok(CreateSubscriptionRequest {
6543 subscription: subscription__,
6544 })
6545 }
6546 }
6547 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
6548 }
6549}
6550impl serde::Serialize for CreateSubscriptionResponse {
6551 #[allow(deprecated)]
6552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6553 where
6554 S: serde::Serializer,
6555 {
6556 use serde::ser::SerializeStruct;
6557 let mut len = 0;
6558 if self.status.is_some() {
6559 len += 1;
6560 }
6561 if self.version.is_some() {
6562 len += 1;
6563 }
6564 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
6565 if let Some(v) = self.status.as_ref() {
6566 struct_ser.serialize_field("status", v)?;
6567 }
6568 if let Some(v) = self.version.as_ref() {
6569 struct_ser.serialize_field("version", v)?;
6570 }
6571 struct_ser.end()
6572 }
6573}
6574impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
6575 #[allow(deprecated)]
6576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6577 where
6578 D: serde::Deserializer<'de>,
6579 {
6580 const FIELDS: &[&str] = &[
6581 "status",
6582 "version",
6583 ];
6584
6585 #[allow(clippy::enum_variant_names)]
6586 enum GeneratedField {
6587 Status,
6588 Version,
6589 }
6590 impl<'de> serde::Deserialize<'de> for GeneratedField {
6591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6592 where
6593 D: serde::Deserializer<'de>,
6594 {
6595 struct GeneratedVisitor;
6596
6597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6598 type Value = GeneratedField;
6599
6600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6601 write!(formatter, "expected one of: {:?}", &FIELDS)
6602 }
6603
6604 #[allow(unused_variables)]
6605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6606 where
6607 E: serde::de::Error,
6608 {
6609 match value {
6610 "status" => Ok(GeneratedField::Status),
6611 "version" => Ok(GeneratedField::Version),
6612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6613 }
6614 }
6615 }
6616 deserializer.deserialize_identifier(GeneratedVisitor)
6617 }
6618 }
6619 struct GeneratedVisitor;
6620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6621 type Value = CreateSubscriptionResponse;
6622
6623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6624 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
6625 }
6626
6627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
6628 where
6629 V: serde::de::MapAccess<'de>,
6630 {
6631 let mut status__ = None;
6632 let mut version__ = None;
6633 while let Some(k) = map_.next_key()? {
6634 match k {
6635 GeneratedField::Status => {
6636 if status__.is_some() {
6637 return Err(serde::de::Error::duplicate_field("status"));
6638 }
6639 status__ = map_.next_value()?;
6640 }
6641 GeneratedField::Version => {
6642 if version__.is_some() {
6643 return Err(serde::de::Error::duplicate_field("version"));
6644 }
6645 version__ = map_.next_value()?;
6646 }
6647 }
6648 }
6649 Ok(CreateSubscriptionResponse {
6650 status: status__,
6651 version: version__,
6652 })
6653 }
6654 }
6655 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
6656 }
6657}
6658impl serde::Serialize for CreateTableRequest {
6659 #[allow(deprecated)]
6660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6661 where
6662 S: serde::Serializer,
6663 {
6664 use serde::ser::SerializeStruct;
6665 let mut len = 0;
6666 if self.source.is_some() {
6667 len += 1;
6668 }
6669 if self.materialized_view.is_some() {
6670 len += 1;
6671 }
6672 if self.fragment_graph.is_some() {
6673 len += 1;
6674 }
6675 if self.job_type != 0 {
6676 len += 1;
6677 }
6678 if self.if_not_exists {
6679 len += 1;
6680 }
6681 if !self.dependencies.is_empty() {
6682 len += 1;
6683 }
6684 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
6685 if let Some(v) = self.source.as_ref() {
6686 struct_ser.serialize_field("source", v)?;
6687 }
6688 if let Some(v) = self.materialized_view.as_ref() {
6689 struct_ser.serialize_field("materializedView", v)?;
6690 }
6691 if let Some(v) = self.fragment_graph.as_ref() {
6692 struct_ser.serialize_field("fragmentGraph", v)?;
6693 }
6694 if self.job_type != 0 {
6695 let v = TableJobType::try_from(self.job_type)
6696 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
6697 struct_ser.serialize_field("jobType", &v)?;
6698 }
6699 if self.if_not_exists {
6700 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6701 }
6702 if !self.dependencies.is_empty() {
6703 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6704 }
6705 struct_ser.end()
6706 }
6707}
6708impl<'de> serde::Deserialize<'de> for CreateTableRequest {
6709 #[allow(deprecated)]
6710 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6711 where
6712 D: serde::Deserializer<'de>,
6713 {
6714 const FIELDS: &[&str] = &[
6715 "source",
6716 "materialized_view",
6717 "materializedView",
6718 "fragment_graph",
6719 "fragmentGraph",
6720 "job_type",
6721 "jobType",
6722 "if_not_exists",
6723 "ifNotExists",
6724 "dependencies",
6725 ];
6726
6727 #[allow(clippy::enum_variant_names)]
6728 enum GeneratedField {
6729 Source,
6730 MaterializedView,
6731 FragmentGraph,
6732 JobType,
6733 IfNotExists,
6734 Dependencies,
6735 }
6736 impl<'de> serde::Deserialize<'de> for GeneratedField {
6737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6738 where
6739 D: serde::Deserializer<'de>,
6740 {
6741 struct GeneratedVisitor;
6742
6743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6744 type Value = GeneratedField;
6745
6746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6747 write!(formatter, "expected one of: {:?}", &FIELDS)
6748 }
6749
6750 #[allow(unused_variables)]
6751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6752 where
6753 E: serde::de::Error,
6754 {
6755 match value {
6756 "source" => Ok(GeneratedField::Source),
6757 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
6758 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6759 "jobType" | "job_type" => Ok(GeneratedField::JobType),
6760 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6761 "dependencies" => Ok(GeneratedField::Dependencies),
6762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6763 }
6764 }
6765 }
6766 deserializer.deserialize_identifier(GeneratedVisitor)
6767 }
6768 }
6769 struct GeneratedVisitor;
6770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6771 type Value = CreateTableRequest;
6772
6773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6774 formatter.write_str("struct ddl_service.CreateTableRequest")
6775 }
6776
6777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
6778 where
6779 V: serde::de::MapAccess<'de>,
6780 {
6781 let mut source__ = None;
6782 let mut materialized_view__ = None;
6783 let mut fragment_graph__ = None;
6784 let mut job_type__ = None;
6785 let mut if_not_exists__ = None;
6786 let mut dependencies__ = None;
6787 while let Some(k) = map_.next_key()? {
6788 match k {
6789 GeneratedField::Source => {
6790 if source__.is_some() {
6791 return Err(serde::de::Error::duplicate_field("source"));
6792 }
6793 source__ = map_.next_value()?;
6794 }
6795 GeneratedField::MaterializedView => {
6796 if materialized_view__.is_some() {
6797 return Err(serde::de::Error::duplicate_field("materializedView"));
6798 }
6799 materialized_view__ = map_.next_value()?;
6800 }
6801 GeneratedField::FragmentGraph => {
6802 if fragment_graph__.is_some() {
6803 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6804 }
6805 fragment_graph__ = map_.next_value()?;
6806 }
6807 GeneratedField::JobType => {
6808 if job_type__.is_some() {
6809 return Err(serde::de::Error::duplicate_field("jobType"));
6810 }
6811 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
6812 }
6813 GeneratedField::IfNotExists => {
6814 if if_not_exists__.is_some() {
6815 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6816 }
6817 if_not_exists__ = Some(map_.next_value()?);
6818 }
6819 GeneratedField::Dependencies => {
6820 if dependencies__.is_some() {
6821 return Err(serde::de::Error::duplicate_field("dependencies"));
6822 }
6823 dependencies__ =
6824 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6825 .into_iter().map(|x| x.0).collect())
6826 ;
6827 }
6828 }
6829 }
6830 Ok(CreateTableRequest {
6831 source: source__,
6832 materialized_view: materialized_view__,
6833 fragment_graph: fragment_graph__,
6834 job_type: job_type__.unwrap_or_default(),
6835 if_not_exists: if_not_exists__.unwrap_or_default(),
6836 dependencies: dependencies__.unwrap_or_default(),
6837 })
6838 }
6839 }
6840 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
6841 }
6842}
6843impl serde::Serialize for CreateTableResponse {
6844 #[allow(deprecated)]
6845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6846 where
6847 S: serde::Serializer,
6848 {
6849 use serde::ser::SerializeStruct;
6850 let mut len = 0;
6851 if self.status.is_some() {
6852 len += 1;
6853 }
6854 if self.version.is_some() {
6855 len += 1;
6856 }
6857 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
6858 if let Some(v) = self.status.as_ref() {
6859 struct_ser.serialize_field("status", v)?;
6860 }
6861 if let Some(v) = self.version.as_ref() {
6862 struct_ser.serialize_field("version", v)?;
6863 }
6864 struct_ser.end()
6865 }
6866}
6867impl<'de> serde::Deserialize<'de> for CreateTableResponse {
6868 #[allow(deprecated)]
6869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6870 where
6871 D: serde::Deserializer<'de>,
6872 {
6873 const FIELDS: &[&str] = &[
6874 "status",
6875 "version",
6876 ];
6877
6878 #[allow(clippy::enum_variant_names)]
6879 enum GeneratedField {
6880 Status,
6881 Version,
6882 }
6883 impl<'de> serde::Deserialize<'de> for GeneratedField {
6884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6885 where
6886 D: serde::Deserializer<'de>,
6887 {
6888 struct GeneratedVisitor;
6889
6890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6891 type Value = GeneratedField;
6892
6893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6894 write!(formatter, "expected one of: {:?}", &FIELDS)
6895 }
6896
6897 #[allow(unused_variables)]
6898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6899 where
6900 E: serde::de::Error,
6901 {
6902 match value {
6903 "status" => Ok(GeneratedField::Status),
6904 "version" => Ok(GeneratedField::Version),
6905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6906 }
6907 }
6908 }
6909 deserializer.deserialize_identifier(GeneratedVisitor)
6910 }
6911 }
6912 struct GeneratedVisitor;
6913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6914 type Value = CreateTableResponse;
6915
6916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6917 formatter.write_str("struct ddl_service.CreateTableResponse")
6918 }
6919
6920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
6921 where
6922 V: serde::de::MapAccess<'de>,
6923 {
6924 let mut status__ = None;
6925 let mut version__ = None;
6926 while let Some(k) = map_.next_key()? {
6927 match k {
6928 GeneratedField::Status => {
6929 if status__.is_some() {
6930 return Err(serde::de::Error::duplicate_field("status"));
6931 }
6932 status__ = map_.next_value()?;
6933 }
6934 GeneratedField::Version => {
6935 if version__.is_some() {
6936 return Err(serde::de::Error::duplicate_field("version"));
6937 }
6938 version__ = map_.next_value()?;
6939 }
6940 }
6941 }
6942 Ok(CreateTableResponse {
6943 status: status__,
6944 version: version__,
6945 })
6946 }
6947 }
6948 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
6949 }
6950}
6951impl serde::Serialize for CreateViewRequest {
6952 #[allow(deprecated)]
6953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6954 where
6955 S: serde::Serializer,
6956 {
6957 use serde::ser::SerializeStruct;
6958 let mut len = 0;
6959 if self.view.is_some() {
6960 len += 1;
6961 }
6962 if !self.dependencies.is_empty() {
6963 len += 1;
6964 }
6965 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
6966 if let Some(v) = self.view.as_ref() {
6967 struct_ser.serialize_field("view", v)?;
6968 }
6969 if !self.dependencies.is_empty() {
6970 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6971 }
6972 struct_ser.end()
6973 }
6974}
6975impl<'de> serde::Deserialize<'de> for CreateViewRequest {
6976 #[allow(deprecated)]
6977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6978 where
6979 D: serde::Deserializer<'de>,
6980 {
6981 const FIELDS: &[&str] = &[
6982 "view",
6983 "dependencies",
6984 ];
6985
6986 #[allow(clippy::enum_variant_names)]
6987 enum GeneratedField {
6988 View,
6989 Dependencies,
6990 }
6991 impl<'de> serde::Deserialize<'de> for GeneratedField {
6992 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6993 where
6994 D: serde::Deserializer<'de>,
6995 {
6996 struct GeneratedVisitor;
6997
6998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6999 type Value = GeneratedField;
7000
7001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7002 write!(formatter, "expected one of: {:?}", &FIELDS)
7003 }
7004
7005 #[allow(unused_variables)]
7006 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7007 where
7008 E: serde::de::Error,
7009 {
7010 match value {
7011 "view" => Ok(GeneratedField::View),
7012 "dependencies" => Ok(GeneratedField::Dependencies),
7013 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7014 }
7015 }
7016 }
7017 deserializer.deserialize_identifier(GeneratedVisitor)
7018 }
7019 }
7020 struct GeneratedVisitor;
7021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7022 type Value = CreateViewRequest;
7023
7024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7025 formatter.write_str("struct ddl_service.CreateViewRequest")
7026 }
7027
7028 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
7029 where
7030 V: serde::de::MapAccess<'de>,
7031 {
7032 let mut view__ = None;
7033 let mut dependencies__ = None;
7034 while let Some(k) = map_.next_key()? {
7035 match k {
7036 GeneratedField::View => {
7037 if view__.is_some() {
7038 return Err(serde::de::Error::duplicate_field("view"));
7039 }
7040 view__ = map_.next_value()?;
7041 }
7042 GeneratedField::Dependencies => {
7043 if dependencies__.is_some() {
7044 return Err(serde::de::Error::duplicate_field("dependencies"));
7045 }
7046 dependencies__ =
7047 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7048 .into_iter().map(|x| x.0).collect())
7049 ;
7050 }
7051 }
7052 }
7053 Ok(CreateViewRequest {
7054 view: view__,
7055 dependencies: dependencies__.unwrap_or_default(),
7056 })
7057 }
7058 }
7059 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
7060 }
7061}
7062impl serde::Serialize for CreateViewResponse {
7063 #[allow(deprecated)]
7064 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7065 where
7066 S: serde::Serializer,
7067 {
7068 use serde::ser::SerializeStruct;
7069 let mut len = 0;
7070 if self.status.is_some() {
7071 len += 1;
7072 }
7073 if self.version.is_some() {
7074 len += 1;
7075 }
7076 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
7077 if let Some(v) = self.status.as_ref() {
7078 struct_ser.serialize_field("status", v)?;
7079 }
7080 if let Some(v) = self.version.as_ref() {
7081 struct_ser.serialize_field("version", v)?;
7082 }
7083 struct_ser.end()
7084 }
7085}
7086impl<'de> serde::Deserialize<'de> for CreateViewResponse {
7087 #[allow(deprecated)]
7088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7089 where
7090 D: serde::Deserializer<'de>,
7091 {
7092 const FIELDS: &[&str] = &[
7093 "status",
7094 "version",
7095 ];
7096
7097 #[allow(clippy::enum_variant_names)]
7098 enum GeneratedField {
7099 Status,
7100 Version,
7101 }
7102 impl<'de> serde::Deserialize<'de> for GeneratedField {
7103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7104 where
7105 D: serde::Deserializer<'de>,
7106 {
7107 struct GeneratedVisitor;
7108
7109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7110 type Value = GeneratedField;
7111
7112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7113 write!(formatter, "expected one of: {:?}", &FIELDS)
7114 }
7115
7116 #[allow(unused_variables)]
7117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7118 where
7119 E: serde::de::Error,
7120 {
7121 match value {
7122 "status" => Ok(GeneratedField::Status),
7123 "version" => Ok(GeneratedField::Version),
7124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7125 }
7126 }
7127 }
7128 deserializer.deserialize_identifier(GeneratedVisitor)
7129 }
7130 }
7131 struct GeneratedVisitor;
7132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7133 type Value = CreateViewResponse;
7134
7135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7136 formatter.write_str("struct ddl_service.CreateViewResponse")
7137 }
7138
7139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
7140 where
7141 V: serde::de::MapAccess<'de>,
7142 {
7143 let mut status__ = None;
7144 let mut version__ = None;
7145 while let Some(k) = map_.next_key()? {
7146 match k {
7147 GeneratedField::Status => {
7148 if status__.is_some() {
7149 return Err(serde::de::Error::duplicate_field("status"));
7150 }
7151 status__ = map_.next_value()?;
7152 }
7153 GeneratedField::Version => {
7154 if version__.is_some() {
7155 return Err(serde::de::Error::duplicate_field("version"));
7156 }
7157 version__ = map_.next_value()?;
7158 }
7159 }
7160 }
7161 Ok(CreateViewResponse {
7162 status: status__,
7163 version: version__,
7164 })
7165 }
7166 }
7167 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
7168 }
7169}
7170impl serde::Serialize for DdlProgress {
7171 #[allow(deprecated)]
7172 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7173 where
7174 S: serde::Serializer,
7175 {
7176 use serde::ser::SerializeStruct;
7177 let mut len = 0;
7178 if self.id != 0 {
7179 len += 1;
7180 }
7181 if !self.statement.is_empty() {
7182 len += 1;
7183 }
7184 if !self.progress.is_empty() {
7185 len += 1;
7186 }
7187 if !self.create_type.is_empty() {
7188 len += 1;
7189 }
7190 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
7191 if self.id != 0 {
7192 #[allow(clippy::needless_borrow)]
7193 #[allow(clippy::needless_borrows_for_generic_args)]
7194 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7195 }
7196 if !self.statement.is_empty() {
7197 struct_ser.serialize_field("statement", &self.statement)?;
7198 }
7199 if !self.progress.is_empty() {
7200 struct_ser.serialize_field("progress", &self.progress)?;
7201 }
7202 if !self.create_type.is_empty() {
7203 struct_ser.serialize_field("createType", &self.create_type)?;
7204 }
7205 struct_ser.end()
7206 }
7207}
7208impl<'de> serde::Deserialize<'de> for DdlProgress {
7209 #[allow(deprecated)]
7210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7211 where
7212 D: serde::Deserializer<'de>,
7213 {
7214 const FIELDS: &[&str] = &[
7215 "id",
7216 "statement",
7217 "progress",
7218 "create_type",
7219 "createType",
7220 ];
7221
7222 #[allow(clippy::enum_variant_names)]
7223 enum GeneratedField {
7224 Id,
7225 Statement,
7226 Progress,
7227 CreateType,
7228 }
7229 impl<'de> serde::Deserialize<'de> for GeneratedField {
7230 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7231 where
7232 D: serde::Deserializer<'de>,
7233 {
7234 struct GeneratedVisitor;
7235
7236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7237 type Value = GeneratedField;
7238
7239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7240 write!(formatter, "expected one of: {:?}", &FIELDS)
7241 }
7242
7243 #[allow(unused_variables)]
7244 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7245 where
7246 E: serde::de::Error,
7247 {
7248 match value {
7249 "id" => Ok(GeneratedField::Id),
7250 "statement" => Ok(GeneratedField::Statement),
7251 "progress" => Ok(GeneratedField::Progress),
7252 "createType" | "create_type" => Ok(GeneratedField::CreateType),
7253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7254 }
7255 }
7256 }
7257 deserializer.deserialize_identifier(GeneratedVisitor)
7258 }
7259 }
7260 struct GeneratedVisitor;
7261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7262 type Value = DdlProgress;
7263
7264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7265 formatter.write_str("struct ddl_service.DdlProgress")
7266 }
7267
7268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
7269 where
7270 V: serde::de::MapAccess<'de>,
7271 {
7272 let mut id__ = None;
7273 let mut statement__ = None;
7274 let mut progress__ = None;
7275 let mut create_type__ = None;
7276 while let Some(k) = map_.next_key()? {
7277 match k {
7278 GeneratedField::Id => {
7279 if id__.is_some() {
7280 return Err(serde::de::Error::duplicate_field("id"));
7281 }
7282 id__ =
7283 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7284 ;
7285 }
7286 GeneratedField::Statement => {
7287 if statement__.is_some() {
7288 return Err(serde::de::Error::duplicate_field("statement"));
7289 }
7290 statement__ = Some(map_.next_value()?);
7291 }
7292 GeneratedField::Progress => {
7293 if progress__.is_some() {
7294 return Err(serde::de::Error::duplicate_field("progress"));
7295 }
7296 progress__ = Some(map_.next_value()?);
7297 }
7298 GeneratedField::CreateType => {
7299 if create_type__.is_some() {
7300 return Err(serde::de::Error::duplicate_field("createType"));
7301 }
7302 create_type__ = Some(map_.next_value()?);
7303 }
7304 }
7305 }
7306 Ok(DdlProgress {
7307 id: id__.unwrap_or_default(),
7308 statement: statement__.unwrap_or_default(),
7309 progress: progress__.unwrap_or_default(),
7310 create_type: create_type__.unwrap_or_default(),
7311 })
7312 }
7313 }
7314 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
7315 }
7316}
7317impl serde::Serialize for DropConnectionRequest {
7318 #[allow(deprecated)]
7319 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7320 where
7321 S: serde::Serializer,
7322 {
7323 use serde::ser::SerializeStruct;
7324 let mut len = 0;
7325 if self.connection_id != 0 {
7326 len += 1;
7327 }
7328 if self.cascade {
7329 len += 1;
7330 }
7331 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
7332 if self.connection_id != 0 {
7333 struct_ser.serialize_field("connectionId", &self.connection_id)?;
7334 }
7335 if self.cascade {
7336 struct_ser.serialize_field("cascade", &self.cascade)?;
7337 }
7338 struct_ser.end()
7339 }
7340}
7341impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
7342 #[allow(deprecated)]
7343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7344 where
7345 D: serde::Deserializer<'de>,
7346 {
7347 const FIELDS: &[&str] = &[
7348 "connection_id",
7349 "connectionId",
7350 "cascade",
7351 ];
7352
7353 #[allow(clippy::enum_variant_names)]
7354 enum GeneratedField {
7355 ConnectionId,
7356 Cascade,
7357 }
7358 impl<'de> serde::Deserialize<'de> for GeneratedField {
7359 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7360 where
7361 D: serde::Deserializer<'de>,
7362 {
7363 struct GeneratedVisitor;
7364
7365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7366 type Value = GeneratedField;
7367
7368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7369 write!(formatter, "expected one of: {:?}", &FIELDS)
7370 }
7371
7372 #[allow(unused_variables)]
7373 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7374 where
7375 E: serde::de::Error,
7376 {
7377 match value {
7378 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
7379 "cascade" => Ok(GeneratedField::Cascade),
7380 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7381 }
7382 }
7383 }
7384 deserializer.deserialize_identifier(GeneratedVisitor)
7385 }
7386 }
7387 struct GeneratedVisitor;
7388 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7389 type Value = DropConnectionRequest;
7390
7391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7392 formatter.write_str("struct ddl_service.DropConnectionRequest")
7393 }
7394
7395 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
7396 where
7397 V: serde::de::MapAccess<'de>,
7398 {
7399 let mut connection_id__ = None;
7400 let mut cascade__ = None;
7401 while let Some(k) = map_.next_key()? {
7402 match k {
7403 GeneratedField::ConnectionId => {
7404 if connection_id__.is_some() {
7405 return Err(serde::de::Error::duplicate_field("connectionId"));
7406 }
7407 connection_id__ =
7408 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7409 ;
7410 }
7411 GeneratedField::Cascade => {
7412 if cascade__.is_some() {
7413 return Err(serde::de::Error::duplicate_field("cascade"));
7414 }
7415 cascade__ = Some(map_.next_value()?);
7416 }
7417 }
7418 }
7419 Ok(DropConnectionRequest {
7420 connection_id: connection_id__.unwrap_or_default(),
7421 cascade: cascade__.unwrap_or_default(),
7422 })
7423 }
7424 }
7425 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
7426 }
7427}
7428impl serde::Serialize for DropConnectionResponse {
7429 #[allow(deprecated)]
7430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7431 where
7432 S: serde::Serializer,
7433 {
7434 use serde::ser::SerializeStruct;
7435 let mut len = 0;
7436 if self.status.is_some() {
7437 len += 1;
7438 }
7439 if self.version.is_some() {
7440 len += 1;
7441 }
7442 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
7443 if let Some(v) = self.status.as_ref() {
7444 struct_ser.serialize_field("status", v)?;
7445 }
7446 if let Some(v) = self.version.as_ref() {
7447 struct_ser.serialize_field("version", v)?;
7448 }
7449 struct_ser.end()
7450 }
7451}
7452impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
7453 #[allow(deprecated)]
7454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7455 where
7456 D: serde::Deserializer<'de>,
7457 {
7458 const FIELDS: &[&str] = &[
7459 "status",
7460 "version",
7461 ];
7462
7463 #[allow(clippy::enum_variant_names)]
7464 enum GeneratedField {
7465 Status,
7466 Version,
7467 }
7468 impl<'de> serde::Deserialize<'de> for GeneratedField {
7469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7470 where
7471 D: serde::Deserializer<'de>,
7472 {
7473 struct GeneratedVisitor;
7474
7475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7476 type Value = GeneratedField;
7477
7478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7479 write!(formatter, "expected one of: {:?}", &FIELDS)
7480 }
7481
7482 #[allow(unused_variables)]
7483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7484 where
7485 E: serde::de::Error,
7486 {
7487 match value {
7488 "status" => Ok(GeneratedField::Status),
7489 "version" => Ok(GeneratedField::Version),
7490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7491 }
7492 }
7493 }
7494 deserializer.deserialize_identifier(GeneratedVisitor)
7495 }
7496 }
7497 struct GeneratedVisitor;
7498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7499 type Value = DropConnectionResponse;
7500
7501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7502 formatter.write_str("struct ddl_service.DropConnectionResponse")
7503 }
7504
7505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
7506 where
7507 V: serde::de::MapAccess<'de>,
7508 {
7509 let mut status__ = None;
7510 let mut version__ = None;
7511 while let Some(k) = map_.next_key()? {
7512 match k {
7513 GeneratedField::Status => {
7514 if status__.is_some() {
7515 return Err(serde::de::Error::duplicate_field("status"));
7516 }
7517 status__ = map_.next_value()?;
7518 }
7519 GeneratedField::Version => {
7520 if version__.is_some() {
7521 return Err(serde::de::Error::duplicate_field("version"));
7522 }
7523 version__ = map_.next_value()?;
7524 }
7525 }
7526 }
7527 Ok(DropConnectionResponse {
7528 status: status__,
7529 version: version__,
7530 })
7531 }
7532 }
7533 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
7534 }
7535}
7536impl serde::Serialize for DropDatabaseRequest {
7537 #[allow(deprecated)]
7538 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7539 where
7540 S: serde::Serializer,
7541 {
7542 use serde::ser::SerializeStruct;
7543 let mut len = 0;
7544 if self.database_id != 0 {
7545 len += 1;
7546 }
7547 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
7548 if self.database_id != 0 {
7549 struct_ser.serialize_field("databaseId", &self.database_id)?;
7550 }
7551 struct_ser.end()
7552 }
7553}
7554impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
7555 #[allow(deprecated)]
7556 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7557 where
7558 D: serde::Deserializer<'de>,
7559 {
7560 const FIELDS: &[&str] = &[
7561 "database_id",
7562 "databaseId",
7563 ];
7564
7565 #[allow(clippy::enum_variant_names)]
7566 enum GeneratedField {
7567 DatabaseId,
7568 }
7569 impl<'de> serde::Deserialize<'de> for GeneratedField {
7570 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7571 where
7572 D: serde::Deserializer<'de>,
7573 {
7574 struct GeneratedVisitor;
7575
7576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7577 type Value = GeneratedField;
7578
7579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7580 write!(formatter, "expected one of: {:?}", &FIELDS)
7581 }
7582
7583 #[allow(unused_variables)]
7584 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7585 where
7586 E: serde::de::Error,
7587 {
7588 match value {
7589 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7590 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7591 }
7592 }
7593 }
7594 deserializer.deserialize_identifier(GeneratedVisitor)
7595 }
7596 }
7597 struct GeneratedVisitor;
7598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7599 type Value = DropDatabaseRequest;
7600
7601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7602 formatter.write_str("struct ddl_service.DropDatabaseRequest")
7603 }
7604
7605 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
7606 where
7607 V: serde::de::MapAccess<'de>,
7608 {
7609 let mut database_id__ = None;
7610 while let Some(k) = map_.next_key()? {
7611 match k {
7612 GeneratedField::DatabaseId => {
7613 if database_id__.is_some() {
7614 return Err(serde::de::Error::duplicate_field("databaseId"));
7615 }
7616 database_id__ =
7617 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7618 ;
7619 }
7620 }
7621 }
7622 Ok(DropDatabaseRequest {
7623 database_id: database_id__.unwrap_or_default(),
7624 })
7625 }
7626 }
7627 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
7628 }
7629}
7630impl serde::Serialize for DropDatabaseResponse {
7631 #[allow(deprecated)]
7632 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7633 where
7634 S: serde::Serializer,
7635 {
7636 use serde::ser::SerializeStruct;
7637 let mut len = 0;
7638 if self.status.is_some() {
7639 len += 1;
7640 }
7641 if self.version.is_some() {
7642 len += 1;
7643 }
7644 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
7645 if let Some(v) = self.status.as_ref() {
7646 struct_ser.serialize_field("status", v)?;
7647 }
7648 if let Some(v) = self.version.as_ref() {
7649 struct_ser.serialize_field("version", v)?;
7650 }
7651 struct_ser.end()
7652 }
7653}
7654impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
7655 #[allow(deprecated)]
7656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7657 where
7658 D: serde::Deserializer<'de>,
7659 {
7660 const FIELDS: &[&str] = &[
7661 "status",
7662 "version",
7663 ];
7664
7665 #[allow(clippy::enum_variant_names)]
7666 enum GeneratedField {
7667 Status,
7668 Version,
7669 }
7670 impl<'de> serde::Deserialize<'de> for GeneratedField {
7671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7672 where
7673 D: serde::Deserializer<'de>,
7674 {
7675 struct GeneratedVisitor;
7676
7677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7678 type Value = GeneratedField;
7679
7680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7681 write!(formatter, "expected one of: {:?}", &FIELDS)
7682 }
7683
7684 #[allow(unused_variables)]
7685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7686 where
7687 E: serde::de::Error,
7688 {
7689 match value {
7690 "status" => Ok(GeneratedField::Status),
7691 "version" => Ok(GeneratedField::Version),
7692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7693 }
7694 }
7695 }
7696 deserializer.deserialize_identifier(GeneratedVisitor)
7697 }
7698 }
7699 struct GeneratedVisitor;
7700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7701 type Value = DropDatabaseResponse;
7702
7703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7704 formatter.write_str("struct ddl_service.DropDatabaseResponse")
7705 }
7706
7707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
7708 where
7709 V: serde::de::MapAccess<'de>,
7710 {
7711 let mut status__ = None;
7712 let mut version__ = None;
7713 while let Some(k) = map_.next_key()? {
7714 match k {
7715 GeneratedField::Status => {
7716 if status__.is_some() {
7717 return Err(serde::de::Error::duplicate_field("status"));
7718 }
7719 status__ = map_.next_value()?;
7720 }
7721 GeneratedField::Version => {
7722 if version__.is_some() {
7723 return Err(serde::de::Error::duplicate_field("version"));
7724 }
7725 version__ = map_.next_value()?;
7726 }
7727 }
7728 }
7729 Ok(DropDatabaseResponse {
7730 status: status__,
7731 version: version__,
7732 })
7733 }
7734 }
7735 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
7736 }
7737}
7738impl serde::Serialize for DropFunctionRequest {
7739 #[allow(deprecated)]
7740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7741 where
7742 S: serde::Serializer,
7743 {
7744 use serde::ser::SerializeStruct;
7745 let mut len = 0;
7746 if self.function_id != 0 {
7747 len += 1;
7748 }
7749 if self.cascade {
7750 len += 1;
7751 }
7752 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
7753 if self.function_id != 0 {
7754 struct_ser.serialize_field("functionId", &self.function_id)?;
7755 }
7756 if self.cascade {
7757 struct_ser.serialize_field("cascade", &self.cascade)?;
7758 }
7759 struct_ser.end()
7760 }
7761}
7762impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
7763 #[allow(deprecated)]
7764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7765 where
7766 D: serde::Deserializer<'de>,
7767 {
7768 const FIELDS: &[&str] = &[
7769 "function_id",
7770 "functionId",
7771 "cascade",
7772 ];
7773
7774 #[allow(clippy::enum_variant_names)]
7775 enum GeneratedField {
7776 FunctionId,
7777 Cascade,
7778 }
7779 impl<'de> serde::Deserialize<'de> for GeneratedField {
7780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7781 where
7782 D: serde::Deserializer<'de>,
7783 {
7784 struct GeneratedVisitor;
7785
7786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7787 type Value = GeneratedField;
7788
7789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7790 write!(formatter, "expected one of: {:?}", &FIELDS)
7791 }
7792
7793 #[allow(unused_variables)]
7794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7795 where
7796 E: serde::de::Error,
7797 {
7798 match value {
7799 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
7800 "cascade" => Ok(GeneratedField::Cascade),
7801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7802 }
7803 }
7804 }
7805 deserializer.deserialize_identifier(GeneratedVisitor)
7806 }
7807 }
7808 struct GeneratedVisitor;
7809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7810 type Value = DropFunctionRequest;
7811
7812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7813 formatter.write_str("struct ddl_service.DropFunctionRequest")
7814 }
7815
7816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
7817 where
7818 V: serde::de::MapAccess<'de>,
7819 {
7820 let mut function_id__ = None;
7821 let mut cascade__ = None;
7822 while let Some(k) = map_.next_key()? {
7823 match k {
7824 GeneratedField::FunctionId => {
7825 if function_id__.is_some() {
7826 return Err(serde::de::Error::duplicate_field("functionId"));
7827 }
7828 function_id__ =
7829 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7830 ;
7831 }
7832 GeneratedField::Cascade => {
7833 if cascade__.is_some() {
7834 return Err(serde::de::Error::duplicate_field("cascade"));
7835 }
7836 cascade__ = Some(map_.next_value()?);
7837 }
7838 }
7839 }
7840 Ok(DropFunctionRequest {
7841 function_id: function_id__.unwrap_or_default(),
7842 cascade: cascade__.unwrap_or_default(),
7843 })
7844 }
7845 }
7846 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
7847 }
7848}
7849impl serde::Serialize for DropFunctionResponse {
7850 #[allow(deprecated)]
7851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7852 where
7853 S: serde::Serializer,
7854 {
7855 use serde::ser::SerializeStruct;
7856 let mut len = 0;
7857 if self.status.is_some() {
7858 len += 1;
7859 }
7860 if self.version.is_some() {
7861 len += 1;
7862 }
7863 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
7864 if let Some(v) = self.status.as_ref() {
7865 struct_ser.serialize_field("status", v)?;
7866 }
7867 if let Some(v) = self.version.as_ref() {
7868 struct_ser.serialize_field("version", v)?;
7869 }
7870 struct_ser.end()
7871 }
7872}
7873impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
7874 #[allow(deprecated)]
7875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7876 where
7877 D: serde::Deserializer<'de>,
7878 {
7879 const FIELDS: &[&str] = &[
7880 "status",
7881 "version",
7882 ];
7883
7884 #[allow(clippy::enum_variant_names)]
7885 enum GeneratedField {
7886 Status,
7887 Version,
7888 }
7889 impl<'de> serde::Deserialize<'de> for GeneratedField {
7890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7891 where
7892 D: serde::Deserializer<'de>,
7893 {
7894 struct GeneratedVisitor;
7895
7896 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7897 type Value = GeneratedField;
7898
7899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7900 write!(formatter, "expected one of: {:?}", &FIELDS)
7901 }
7902
7903 #[allow(unused_variables)]
7904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7905 where
7906 E: serde::de::Error,
7907 {
7908 match value {
7909 "status" => Ok(GeneratedField::Status),
7910 "version" => Ok(GeneratedField::Version),
7911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7912 }
7913 }
7914 }
7915 deserializer.deserialize_identifier(GeneratedVisitor)
7916 }
7917 }
7918 struct GeneratedVisitor;
7919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7920 type Value = DropFunctionResponse;
7921
7922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7923 formatter.write_str("struct ddl_service.DropFunctionResponse")
7924 }
7925
7926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
7927 where
7928 V: serde::de::MapAccess<'de>,
7929 {
7930 let mut status__ = None;
7931 let mut version__ = None;
7932 while let Some(k) = map_.next_key()? {
7933 match k {
7934 GeneratedField::Status => {
7935 if status__.is_some() {
7936 return Err(serde::de::Error::duplicate_field("status"));
7937 }
7938 status__ = map_.next_value()?;
7939 }
7940 GeneratedField::Version => {
7941 if version__.is_some() {
7942 return Err(serde::de::Error::duplicate_field("version"));
7943 }
7944 version__ = map_.next_value()?;
7945 }
7946 }
7947 }
7948 Ok(DropFunctionResponse {
7949 status: status__,
7950 version: version__,
7951 })
7952 }
7953 }
7954 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
7955 }
7956}
7957impl serde::Serialize for DropIndexRequest {
7958 #[allow(deprecated)]
7959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7960 where
7961 S: serde::Serializer,
7962 {
7963 use serde::ser::SerializeStruct;
7964 let mut len = 0;
7965 if self.index_id != 0 {
7966 len += 1;
7967 }
7968 if self.cascade {
7969 len += 1;
7970 }
7971 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
7972 if self.index_id != 0 {
7973 struct_ser.serialize_field("indexId", &self.index_id)?;
7974 }
7975 if self.cascade {
7976 struct_ser.serialize_field("cascade", &self.cascade)?;
7977 }
7978 struct_ser.end()
7979 }
7980}
7981impl<'de> serde::Deserialize<'de> for DropIndexRequest {
7982 #[allow(deprecated)]
7983 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7984 where
7985 D: serde::Deserializer<'de>,
7986 {
7987 const FIELDS: &[&str] = &[
7988 "index_id",
7989 "indexId",
7990 "cascade",
7991 ];
7992
7993 #[allow(clippy::enum_variant_names)]
7994 enum GeneratedField {
7995 IndexId,
7996 Cascade,
7997 }
7998 impl<'de> serde::Deserialize<'de> for GeneratedField {
7999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8000 where
8001 D: serde::Deserializer<'de>,
8002 {
8003 struct GeneratedVisitor;
8004
8005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8006 type Value = GeneratedField;
8007
8008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8009 write!(formatter, "expected one of: {:?}", &FIELDS)
8010 }
8011
8012 #[allow(unused_variables)]
8013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8014 where
8015 E: serde::de::Error,
8016 {
8017 match value {
8018 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8019 "cascade" => Ok(GeneratedField::Cascade),
8020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8021 }
8022 }
8023 }
8024 deserializer.deserialize_identifier(GeneratedVisitor)
8025 }
8026 }
8027 struct GeneratedVisitor;
8028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8029 type Value = DropIndexRequest;
8030
8031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8032 formatter.write_str("struct ddl_service.DropIndexRequest")
8033 }
8034
8035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
8036 where
8037 V: serde::de::MapAccess<'de>,
8038 {
8039 let mut index_id__ = None;
8040 let mut cascade__ = None;
8041 while let Some(k) = map_.next_key()? {
8042 match k {
8043 GeneratedField::IndexId => {
8044 if index_id__.is_some() {
8045 return Err(serde::de::Error::duplicate_field("indexId"));
8046 }
8047 index_id__ =
8048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8049 ;
8050 }
8051 GeneratedField::Cascade => {
8052 if cascade__.is_some() {
8053 return Err(serde::de::Error::duplicate_field("cascade"));
8054 }
8055 cascade__ = Some(map_.next_value()?);
8056 }
8057 }
8058 }
8059 Ok(DropIndexRequest {
8060 index_id: index_id__.unwrap_or_default(),
8061 cascade: cascade__.unwrap_or_default(),
8062 })
8063 }
8064 }
8065 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
8066 }
8067}
8068impl serde::Serialize for DropIndexResponse {
8069 #[allow(deprecated)]
8070 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8071 where
8072 S: serde::Serializer,
8073 {
8074 use serde::ser::SerializeStruct;
8075 let mut len = 0;
8076 if self.status.is_some() {
8077 len += 1;
8078 }
8079 if self.version.is_some() {
8080 len += 1;
8081 }
8082 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
8083 if let Some(v) = self.status.as_ref() {
8084 struct_ser.serialize_field("status", v)?;
8085 }
8086 if let Some(v) = self.version.as_ref() {
8087 struct_ser.serialize_field("version", v)?;
8088 }
8089 struct_ser.end()
8090 }
8091}
8092impl<'de> serde::Deserialize<'de> for DropIndexResponse {
8093 #[allow(deprecated)]
8094 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8095 where
8096 D: serde::Deserializer<'de>,
8097 {
8098 const FIELDS: &[&str] = &[
8099 "status",
8100 "version",
8101 ];
8102
8103 #[allow(clippy::enum_variant_names)]
8104 enum GeneratedField {
8105 Status,
8106 Version,
8107 }
8108 impl<'de> serde::Deserialize<'de> for GeneratedField {
8109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8110 where
8111 D: serde::Deserializer<'de>,
8112 {
8113 struct GeneratedVisitor;
8114
8115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8116 type Value = GeneratedField;
8117
8118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8119 write!(formatter, "expected one of: {:?}", &FIELDS)
8120 }
8121
8122 #[allow(unused_variables)]
8123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8124 where
8125 E: serde::de::Error,
8126 {
8127 match value {
8128 "status" => Ok(GeneratedField::Status),
8129 "version" => Ok(GeneratedField::Version),
8130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8131 }
8132 }
8133 }
8134 deserializer.deserialize_identifier(GeneratedVisitor)
8135 }
8136 }
8137 struct GeneratedVisitor;
8138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8139 type Value = DropIndexResponse;
8140
8141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8142 formatter.write_str("struct ddl_service.DropIndexResponse")
8143 }
8144
8145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
8146 where
8147 V: serde::de::MapAccess<'de>,
8148 {
8149 let mut status__ = None;
8150 let mut version__ = None;
8151 while let Some(k) = map_.next_key()? {
8152 match k {
8153 GeneratedField::Status => {
8154 if status__.is_some() {
8155 return Err(serde::de::Error::duplicate_field("status"));
8156 }
8157 status__ = map_.next_value()?;
8158 }
8159 GeneratedField::Version => {
8160 if version__.is_some() {
8161 return Err(serde::de::Error::duplicate_field("version"));
8162 }
8163 version__ = map_.next_value()?;
8164 }
8165 }
8166 }
8167 Ok(DropIndexResponse {
8168 status: status__,
8169 version: version__,
8170 })
8171 }
8172 }
8173 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
8174 }
8175}
8176impl serde::Serialize for DropMaterializedViewRequest {
8177 #[allow(deprecated)]
8178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8179 where
8180 S: serde::Serializer,
8181 {
8182 use serde::ser::SerializeStruct;
8183 let mut len = 0;
8184 if self.table_id != 0 {
8185 len += 1;
8186 }
8187 if self.cascade {
8188 len += 1;
8189 }
8190 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
8191 if self.table_id != 0 {
8192 struct_ser.serialize_field("tableId", &self.table_id)?;
8193 }
8194 if self.cascade {
8195 struct_ser.serialize_field("cascade", &self.cascade)?;
8196 }
8197 struct_ser.end()
8198 }
8199}
8200impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
8201 #[allow(deprecated)]
8202 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8203 where
8204 D: serde::Deserializer<'de>,
8205 {
8206 const FIELDS: &[&str] = &[
8207 "table_id",
8208 "tableId",
8209 "cascade",
8210 ];
8211
8212 #[allow(clippy::enum_variant_names)]
8213 enum GeneratedField {
8214 TableId,
8215 Cascade,
8216 }
8217 impl<'de> serde::Deserialize<'de> for GeneratedField {
8218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8219 where
8220 D: serde::Deserializer<'de>,
8221 {
8222 struct GeneratedVisitor;
8223
8224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8225 type Value = GeneratedField;
8226
8227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8228 write!(formatter, "expected one of: {:?}", &FIELDS)
8229 }
8230
8231 #[allow(unused_variables)]
8232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8233 where
8234 E: serde::de::Error,
8235 {
8236 match value {
8237 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8238 "cascade" => Ok(GeneratedField::Cascade),
8239 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8240 }
8241 }
8242 }
8243 deserializer.deserialize_identifier(GeneratedVisitor)
8244 }
8245 }
8246 struct GeneratedVisitor;
8247 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8248 type Value = DropMaterializedViewRequest;
8249
8250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8251 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
8252 }
8253
8254 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
8255 where
8256 V: serde::de::MapAccess<'de>,
8257 {
8258 let mut table_id__ = None;
8259 let mut cascade__ = None;
8260 while let Some(k) = map_.next_key()? {
8261 match k {
8262 GeneratedField::TableId => {
8263 if table_id__.is_some() {
8264 return Err(serde::de::Error::duplicate_field("tableId"));
8265 }
8266 table_id__ =
8267 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8268 ;
8269 }
8270 GeneratedField::Cascade => {
8271 if cascade__.is_some() {
8272 return Err(serde::de::Error::duplicate_field("cascade"));
8273 }
8274 cascade__ = Some(map_.next_value()?);
8275 }
8276 }
8277 }
8278 Ok(DropMaterializedViewRequest {
8279 table_id: table_id__.unwrap_or_default(),
8280 cascade: cascade__.unwrap_or_default(),
8281 })
8282 }
8283 }
8284 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
8285 }
8286}
8287impl serde::Serialize for DropMaterializedViewResponse {
8288 #[allow(deprecated)]
8289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8290 where
8291 S: serde::Serializer,
8292 {
8293 use serde::ser::SerializeStruct;
8294 let mut len = 0;
8295 if self.status.is_some() {
8296 len += 1;
8297 }
8298 if self.version.is_some() {
8299 len += 1;
8300 }
8301 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
8302 if let Some(v) = self.status.as_ref() {
8303 struct_ser.serialize_field("status", v)?;
8304 }
8305 if let Some(v) = self.version.as_ref() {
8306 struct_ser.serialize_field("version", v)?;
8307 }
8308 struct_ser.end()
8309 }
8310}
8311impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
8312 #[allow(deprecated)]
8313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8314 where
8315 D: serde::Deserializer<'de>,
8316 {
8317 const FIELDS: &[&str] = &[
8318 "status",
8319 "version",
8320 ];
8321
8322 #[allow(clippy::enum_variant_names)]
8323 enum GeneratedField {
8324 Status,
8325 Version,
8326 }
8327 impl<'de> serde::Deserialize<'de> for GeneratedField {
8328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8329 where
8330 D: serde::Deserializer<'de>,
8331 {
8332 struct GeneratedVisitor;
8333
8334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8335 type Value = GeneratedField;
8336
8337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8338 write!(formatter, "expected one of: {:?}", &FIELDS)
8339 }
8340
8341 #[allow(unused_variables)]
8342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8343 where
8344 E: serde::de::Error,
8345 {
8346 match value {
8347 "status" => Ok(GeneratedField::Status),
8348 "version" => Ok(GeneratedField::Version),
8349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8350 }
8351 }
8352 }
8353 deserializer.deserialize_identifier(GeneratedVisitor)
8354 }
8355 }
8356 struct GeneratedVisitor;
8357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8358 type Value = DropMaterializedViewResponse;
8359
8360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8361 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
8362 }
8363
8364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
8365 where
8366 V: serde::de::MapAccess<'de>,
8367 {
8368 let mut status__ = None;
8369 let mut version__ = None;
8370 while let Some(k) = map_.next_key()? {
8371 match k {
8372 GeneratedField::Status => {
8373 if status__.is_some() {
8374 return Err(serde::de::Error::duplicate_field("status"));
8375 }
8376 status__ = map_.next_value()?;
8377 }
8378 GeneratedField::Version => {
8379 if version__.is_some() {
8380 return Err(serde::de::Error::duplicate_field("version"));
8381 }
8382 version__ = map_.next_value()?;
8383 }
8384 }
8385 }
8386 Ok(DropMaterializedViewResponse {
8387 status: status__,
8388 version: version__,
8389 })
8390 }
8391 }
8392 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
8393 }
8394}
8395impl serde::Serialize for DropSchemaRequest {
8396 #[allow(deprecated)]
8397 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8398 where
8399 S: serde::Serializer,
8400 {
8401 use serde::ser::SerializeStruct;
8402 let mut len = 0;
8403 if self.schema_id != 0 {
8404 len += 1;
8405 }
8406 if self.cascade {
8407 len += 1;
8408 }
8409 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
8410 if self.schema_id != 0 {
8411 struct_ser.serialize_field("schemaId", &self.schema_id)?;
8412 }
8413 if self.cascade {
8414 struct_ser.serialize_field("cascade", &self.cascade)?;
8415 }
8416 struct_ser.end()
8417 }
8418}
8419impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
8420 #[allow(deprecated)]
8421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8422 where
8423 D: serde::Deserializer<'de>,
8424 {
8425 const FIELDS: &[&str] = &[
8426 "schema_id",
8427 "schemaId",
8428 "cascade",
8429 ];
8430
8431 #[allow(clippy::enum_variant_names)]
8432 enum GeneratedField {
8433 SchemaId,
8434 Cascade,
8435 }
8436 impl<'de> serde::Deserialize<'de> for GeneratedField {
8437 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8438 where
8439 D: serde::Deserializer<'de>,
8440 {
8441 struct GeneratedVisitor;
8442
8443 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8444 type Value = GeneratedField;
8445
8446 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8447 write!(formatter, "expected one of: {:?}", &FIELDS)
8448 }
8449
8450 #[allow(unused_variables)]
8451 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8452 where
8453 E: serde::de::Error,
8454 {
8455 match value {
8456 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
8457 "cascade" => Ok(GeneratedField::Cascade),
8458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8459 }
8460 }
8461 }
8462 deserializer.deserialize_identifier(GeneratedVisitor)
8463 }
8464 }
8465 struct GeneratedVisitor;
8466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8467 type Value = DropSchemaRequest;
8468
8469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8470 formatter.write_str("struct ddl_service.DropSchemaRequest")
8471 }
8472
8473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
8474 where
8475 V: serde::de::MapAccess<'de>,
8476 {
8477 let mut schema_id__ = None;
8478 let mut cascade__ = None;
8479 while let Some(k) = map_.next_key()? {
8480 match k {
8481 GeneratedField::SchemaId => {
8482 if schema_id__.is_some() {
8483 return Err(serde::de::Error::duplicate_field("schemaId"));
8484 }
8485 schema_id__ =
8486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8487 ;
8488 }
8489 GeneratedField::Cascade => {
8490 if cascade__.is_some() {
8491 return Err(serde::de::Error::duplicate_field("cascade"));
8492 }
8493 cascade__ = Some(map_.next_value()?);
8494 }
8495 }
8496 }
8497 Ok(DropSchemaRequest {
8498 schema_id: schema_id__.unwrap_or_default(),
8499 cascade: cascade__.unwrap_or_default(),
8500 })
8501 }
8502 }
8503 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
8504 }
8505}
8506impl serde::Serialize for DropSchemaResponse {
8507 #[allow(deprecated)]
8508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8509 where
8510 S: serde::Serializer,
8511 {
8512 use serde::ser::SerializeStruct;
8513 let mut len = 0;
8514 if self.status.is_some() {
8515 len += 1;
8516 }
8517 if self.version.is_some() {
8518 len += 1;
8519 }
8520 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
8521 if let Some(v) = self.status.as_ref() {
8522 struct_ser.serialize_field("status", v)?;
8523 }
8524 if let Some(v) = self.version.as_ref() {
8525 struct_ser.serialize_field("version", v)?;
8526 }
8527 struct_ser.end()
8528 }
8529}
8530impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
8531 #[allow(deprecated)]
8532 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8533 where
8534 D: serde::Deserializer<'de>,
8535 {
8536 const FIELDS: &[&str] = &[
8537 "status",
8538 "version",
8539 ];
8540
8541 #[allow(clippy::enum_variant_names)]
8542 enum GeneratedField {
8543 Status,
8544 Version,
8545 }
8546 impl<'de> serde::Deserialize<'de> for GeneratedField {
8547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8548 where
8549 D: serde::Deserializer<'de>,
8550 {
8551 struct GeneratedVisitor;
8552
8553 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8554 type Value = GeneratedField;
8555
8556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8557 write!(formatter, "expected one of: {:?}", &FIELDS)
8558 }
8559
8560 #[allow(unused_variables)]
8561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8562 where
8563 E: serde::de::Error,
8564 {
8565 match value {
8566 "status" => Ok(GeneratedField::Status),
8567 "version" => Ok(GeneratedField::Version),
8568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8569 }
8570 }
8571 }
8572 deserializer.deserialize_identifier(GeneratedVisitor)
8573 }
8574 }
8575 struct GeneratedVisitor;
8576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8577 type Value = DropSchemaResponse;
8578
8579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8580 formatter.write_str("struct ddl_service.DropSchemaResponse")
8581 }
8582
8583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
8584 where
8585 V: serde::de::MapAccess<'de>,
8586 {
8587 let mut status__ = None;
8588 let mut version__ = None;
8589 while let Some(k) = map_.next_key()? {
8590 match k {
8591 GeneratedField::Status => {
8592 if status__.is_some() {
8593 return Err(serde::de::Error::duplicate_field("status"));
8594 }
8595 status__ = map_.next_value()?;
8596 }
8597 GeneratedField::Version => {
8598 if version__.is_some() {
8599 return Err(serde::de::Error::duplicate_field("version"));
8600 }
8601 version__ = map_.next_value()?;
8602 }
8603 }
8604 }
8605 Ok(DropSchemaResponse {
8606 status: status__,
8607 version: version__,
8608 })
8609 }
8610 }
8611 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
8612 }
8613}
8614impl serde::Serialize for DropSecretRequest {
8615 #[allow(deprecated)]
8616 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8617 where
8618 S: serde::Serializer,
8619 {
8620 use serde::ser::SerializeStruct;
8621 let mut len = 0;
8622 if self.secret_id != 0 {
8623 len += 1;
8624 }
8625 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
8626 if self.secret_id != 0 {
8627 struct_ser.serialize_field("secretId", &self.secret_id)?;
8628 }
8629 struct_ser.end()
8630 }
8631}
8632impl<'de> serde::Deserialize<'de> for DropSecretRequest {
8633 #[allow(deprecated)]
8634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8635 where
8636 D: serde::Deserializer<'de>,
8637 {
8638 const FIELDS: &[&str] = &[
8639 "secret_id",
8640 "secretId",
8641 ];
8642
8643 #[allow(clippy::enum_variant_names)]
8644 enum GeneratedField {
8645 SecretId,
8646 }
8647 impl<'de> serde::Deserialize<'de> for GeneratedField {
8648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8649 where
8650 D: serde::Deserializer<'de>,
8651 {
8652 struct GeneratedVisitor;
8653
8654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8655 type Value = GeneratedField;
8656
8657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8658 write!(formatter, "expected one of: {:?}", &FIELDS)
8659 }
8660
8661 #[allow(unused_variables)]
8662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8663 where
8664 E: serde::de::Error,
8665 {
8666 match value {
8667 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
8668 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8669 }
8670 }
8671 }
8672 deserializer.deserialize_identifier(GeneratedVisitor)
8673 }
8674 }
8675 struct GeneratedVisitor;
8676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8677 type Value = DropSecretRequest;
8678
8679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8680 formatter.write_str("struct ddl_service.DropSecretRequest")
8681 }
8682
8683 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
8684 where
8685 V: serde::de::MapAccess<'de>,
8686 {
8687 let mut secret_id__ = None;
8688 while let Some(k) = map_.next_key()? {
8689 match k {
8690 GeneratedField::SecretId => {
8691 if secret_id__.is_some() {
8692 return Err(serde::de::Error::duplicate_field("secretId"));
8693 }
8694 secret_id__ =
8695 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8696 ;
8697 }
8698 }
8699 }
8700 Ok(DropSecretRequest {
8701 secret_id: secret_id__.unwrap_or_default(),
8702 })
8703 }
8704 }
8705 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
8706 }
8707}
8708impl serde::Serialize for DropSecretResponse {
8709 #[allow(deprecated)]
8710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8711 where
8712 S: serde::Serializer,
8713 {
8714 use serde::ser::SerializeStruct;
8715 let mut len = 0;
8716 if self.version.is_some() {
8717 len += 1;
8718 }
8719 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
8720 if let Some(v) = self.version.as_ref() {
8721 struct_ser.serialize_field("version", v)?;
8722 }
8723 struct_ser.end()
8724 }
8725}
8726impl<'de> serde::Deserialize<'de> for DropSecretResponse {
8727 #[allow(deprecated)]
8728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8729 where
8730 D: serde::Deserializer<'de>,
8731 {
8732 const FIELDS: &[&str] = &[
8733 "version",
8734 ];
8735
8736 #[allow(clippy::enum_variant_names)]
8737 enum GeneratedField {
8738 Version,
8739 }
8740 impl<'de> serde::Deserialize<'de> for GeneratedField {
8741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8742 where
8743 D: serde::Deserializer<'de>,
8744 {
8745 struct GeneratedVisitor;
8746
8747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8748 type Value = GeneratedField;
8749
8750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8751 write!(formatter, "expected one of: {:?}", &FIELDS)
8752 }
8753
8754 #[allow(unused_variables)]
8755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8756 where
8757 E: serde::de::Error,
8758 {
8759 match value {
8760 "version" => Ok(GeneratedField::Version),
8761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8762 }
8763 }
8764 }
8765 deserializer.deserialize_identifier(GeneratedVisitor)
8766 }
8767 }
8768 struct GeneratedVisitor;
8769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8770 type Value = DropSecretResponse;
8771
8772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8773 formatter.write_str("struct ddl_service.DropSecretResponse")
8774 }
8775
8776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
8777 where
8778 V: serde::de::MapAccess<'de>,
8779 {
8780 let mut version__ = None;
8781 while let Some(k) = map_.next_key()? {
8782 match k {
8783 GeneratedField::Version => {
8784 if version__.is_some() {
8785 return Err(serde::de::Error::duplicate_field("version"));
8786 }
8787 version__ = map_.next_value()?;
8788 }
8789 }
8790 }
8791 Ok(DropSecretResponse {
8792 version: version__,
8793 })
8794 }
8795 }
8796 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
8797 }
8798}
8799impl serde::Serialize for DropSinkRequest {
8800 #[allow(deprecated)]
8801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8802 where
8803 S: serde::Serializer,
8804 {
8805 use serde::ser::SerializeStruct;
8806 let mut len = 0;
8807 if self.sink_id != 0 {
8808 len += 1;
8809 }
8810 if self.cascade {
8811 len += 1;
8812 }
8813 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
8814 if self.sink_id != 0 {
8815 struct_ser.serialize_field("sinkId", &self.sink_id)?;
8816 }
8817 if self.cascade {
8818 struct_ser.serialize_field("cascade", &self.cascade)?;
8819 }
8820 struct_ser.end()
8821 }
8822}
8823impl<'de> serde::Deserialize<'de> for DropSinkRequest {
8824 #[allow(deprecated)]
8825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8826 where
8827 D: serde::Deserializer<'de>,
8828 {
8829 const FIELDS: &[&str] = &[
8830 "sink_id",
8831 "sinkId",
8832 "cascade",
8833 ];
8834
8835 #[allow(clippy::enum_variant_names)]
8836 enum GeneratedField {
8837 SinkId,
8838 Cascade,
8839 }
8840 impl<'de> serde::Deserialize<'de> for GeneratedField {
8841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8842 where
8843 D: serde::Deserializer<'de>,
8844 {
8845 struct GeneratedVisitor;
8846
8847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8848 type Value = GeneratedField;
8849
8850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8851 write!(formatter, "expected one of: {:?}", &FIELDS)
8852 }
8853
8854 #[allow(unused_variables)]
8855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8856 where
8857 E: serde::de::Error,
8858 {
8859 match value {
8860 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
8861 "cascade" => Ok(GeneratedField::Cascade),
8862 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8863 }
8864 }
8865 }
8866 deserializer.deserialize_identifier(GeneratedVisitor)
8867 }
8868 }
8869 struct GeneratedVisitor;
8870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8871 type Value = DropSinkRequest;
8872
8873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8874 formatter.write_str("struct ddl_service.DropSinkRequest")
8875 }
8876
8877 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
8878 where
8879 V: serde::de::MapAccess<'de>,
8880 {
8881 let mut sink_id__ = None;
8882 let mut cascade__ = None;
8883 while let Some(k) = map_.next_key()? {
8884 match k {
8885 GeneratedField::SinkId => {
8886 if sink_id__.is_some() {
8887 return Err(serde::de::Error::duplicate_field("sinkId"));
8888 }
8889 sink_id__ =
8890 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8891 ;
8892 }
8893 GeneratedField::Cascade => {
8894 if cascade__.is_some() {
8895 return Err(serde::de::Error::duplicate_field("cascade"));
8896 }
8897 cascade__ = Some(map_.next_value()?);
8898 }
8899 }
8900 }
8901 Ok(DropSinkRequest {
8902 sink_id: sink_id__.unwrap_or_default(),
8903 cascade: cascade__.unwrap_or_default(),
8904 })
8905 }
8906 }
8907 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
8908 }
8909}
8910impl serde::Serialize for DropSinkResponse {
8911 #[allow(deprecated)]
8912 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8913 where
8914 S: serde::Serializer,
8915 {
8916 use serde::ser::SerializeStruct;
8917 let mut len = 0;
8918 if self.status.is_some() {
8919 len += 1;
8920 }
8921 if self.version.is_some() {
8922 len += 1;
8923 }
8924 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
8925 if let Some(v) = self.status.as_ref() {
8926 struct_ser.serialize_field("status", v)?;
8927 }
8928 if let Some(v) = self.version.as_ref() {
8929 struct_ser.serialize_field("version", v)?;
8930 }
8931 struct_ser.end()
8932 }
8933}
8934impl<'de> serde::Deserialize<'de> for DropSinkResponse {
8935 #[allow(deprecated)]
8936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8937 where
8938 D: serde::Deserializer<'de>,
8939 {
8940 const FIELDS: &[&str] = &[
8941 "status",
8942 "version",
8943 ];
8944
8945 #[allow(clippy::enum_variant_names)]
8946 enum GeneratedField {
8947 Status,
8948 Version,
8949 }
8950 impl<'de> serde::Deserialize<'de> for GeneratedField {
8951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8952 where
8953 D: serde::Deserializer<'de>,
8954 {
8955 struct GeneratedVisitor;
8956
8957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8958 type Value = GeneratedField;
8959
8960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8961 write!(formatter, "expected one of: {:?}", &FIELDS)
8962 }
8963
8964 #[allow(unused_variables)]
8965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8966 where
8967 E: serde::de::Error,
8968 {
8969 match value {
8970 "status" => Ok(GeneratedField::Status),
8971 "version" => Ok(GeneratedField::Version),
8972 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8973 }
8974 }
8975 }
8976 deserializer.deserialize_identifier(GeneratedVisitor)
8977 }
8978 }
8979 struct GeneratedVisitor;
8980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8981 type Value = DropSinkResponse;
8982
8983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8984 formatter.write_str("struct ddl_service.DropSinkResponse")
8985 }
8986
8987 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
8988 where
8989 V: serde::de::MapAccess<'de>,
8990 {
8991 let mut status__ = None;
8992 let mut version__ = None;
8993 while let Some(k) = map_.next_key()? {
8994 match k {
8995 GeneratedField::Status => {
8996 if status__.is_some() {
8997 return Err(serde::de::Error::duplicate_field("status"));
8998 }
8999 status__ = map_.next_value()?;
9000 }
9001 GeneratedField::Version => {
9002 if version__.is_some() {
9003 return Err(serde::de::Error::duplicate_field("version"));
9004 }
9005 version__ = map_.next_value()?;
9006 }
9007 }
9008 }
9009 Ok(DropSinkResponse {
9010 status: status__,
9011 version: version__,
9012 })
9013 }
9014 }
9015 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
9016 }
9017}
9018impl serde::Serialize for DropSourceRequest {
9019 #[allow(deprecated)]
9020 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9021 where
9022 S: serde::Serializer,
9023 {
9024 use serde::ser::SerializeStruct;
9025 let mut len = 0;
9026 if self.source_id != 0 {
9027 len += 1;
9028 }
9029 if self.cascade {
9030 len += 1;
9031 }
9032 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
9033 if self.source_id != 0 {
9034 struct_ser.serialize_field("sourceId", &self.source_id)?;
9035 }
9036 if self.cascade {
9037 struct_ser.serialize_field("cascade", &self.cascade)?;
9038 }
9039 struct_ser.end()
9040 }
9041}
9042impl<'de> serde::Deserialize<'de> for DropSourceRequest {
9043 #[allow(deprecated)]
9044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9045 where
9046 D: serde::Deserializer<'de>,
9047 {
9048 const FIELDS: &[&str] = &[
9049 "source_id",
9050 "sourceId",
9051 "cascade",
9052 ];
9053
9054 #[allow(clippy::enum_variant_names)]
9055 enum GeneratedField {
9056 SourceId,
9057 Cascade,
9058 }
9059 impl<'de> serde::Deserialize<'de> for GeneratedField {
9060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9061 where
9062 D: serde::Deserializer<'de>,
9063 {
9064 struct GeneratedVisitor;
9065
9066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9067 type Value = GeneratedField;
9068
9069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9070 write!(formatter, "expected one of: {:?}", &FIELDS)
9071 }
9072
9073 #[allow(unused_variables)]
9074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9075 where
9076 E: serde::de::Error,
9077 {
9078 match value {
9079 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9080 "cascade" => Ok(GeneratedField::Cascade),
9081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9082 }
9083 }
9084 }
9085 deserializer.deserialize_identifier(GeneratedVisitor)
9086 }
9087 }
9088 struct GeneratedVisitor;
9089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9090 type Value = DropSourceRequest;
9091
9092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9093 formatter.write_str("struct ddl_service.DropSourceRequest")
9094 }
9095
9096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
9097 where
9098 V: serde::de::MapAccess<'de>,
9099 {
9100 let mut source_id__ = None;
9101 let mut cascade__ = None;
9102 while let Some(k) = map_.next_key()? {
9103 match k {
9104 GeneratedField::SourceId => {
9105 if source_id__.is_some() {
9106 return Err(serde::de::Error::duplicate_field("sourceId"));
9107 }
9108 source_id__ =
9109 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9110 ;
9111 }
9112 GeneratedField::Cascade => {
9113 if cascade__.is_some() {
9114 return Err(serde::de::Error::duplicate_field("cascade"));
9115 }
9116 cascade__ = Some(map_.next_value()?);
9117 }
9118 }
9119 }
9120 Ok(DropSourceRequest {
9121 source_id: source_id__.unwrap_or_default(),
9122 cascade: cascade__.unwrap_or_default(),
9123 })
9124 }
9125 }
9126 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
9127 }
9128}
9129impl serde::Serialize for DropSourceResponse {
9130 #[allow(deprecated)]
9131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9132 where
9133 S: serde::Serializer,
9134 {
9135 use serde::ser::SerializeStruct;
9136 let mut len = 0;
9137 if self.status.is_some() {
9138 len += 1;
9139 }
9140 if self.version.is_some() {
9141 len += 1;
9142 }
9143 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
9144 if let Some(v) = self.status.as_ref() {
9145 struct_ser.serialize_field("status", v)?;
9146 }
9147 if let Some(v) = self.version.as_ref() {
9148 struct_ser.serialize_field("version", v)?;
9149 }
9150 struct_ser.end()
9151 }
9152}
9153impl<'de> serde::Deserialize<'de> for DropSourceResponse {
9154 #[allow(deprecated)]
9155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9156 where
9157 D: serde::Deserializer<'de>,
9158 {
9159 const FIELDS: &[&str] = &[
9160 "status",
9161 "version",
9162 ];
9163
9164 #[allow(clippy::enum_variant_names)]
9165 enum GeneratedField {
9166 Status,
9167 Version,
9168 }
9169 impl<'de> serde::Deserialize<'de> for GeneratedField {
9170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9171 where
9172 D: serde::Deserializer<'de>,
9173 {
9174 struct GeneratedVisitor;
9175
9176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9177 type Value = GeneratedField;
9178
9179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9180 write!(formatter, "expected one of: {:?}", &FIELDS)
9181 }
9182
9183 #[allow(unused_variables)]
9184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9185 where
9186 E: serde::de::Error,
9187 {
9188 match value {
9189 "status" => Ok(GeneratedField::Status),
9190 "version" => Ok(GeneratedField::Version),
9191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9192 }
9193 }
9194 }
9195 deserializer.deserialize_identifier(GeneratedVisitor)
9196 }
9197 }
9198 struct GeneratedVisitor;
9199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9200 type Value = DropSourceResponse;
9201
9202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9203 formatter.write_str("struct ddl_service.DropSourceResponse")
9204 }
9205
9206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9207 where
9208 V: serde::de::MapAccess<'de>,
9209 {
9210 let mut status__ = None;
9211 let mut version__ = None;
9212 while let Some(k) = map_.next_key()? {
9213 match k {
9214 GeneratedField::Status => {
9215 if status__.is_some() {
9216 return Err(serde::de::Error::duplicate_field("status"));
9217 }
9218 status__ = map_.next_value()?;
9219 }
9220 GeneratedField::Version => {
9221 if version__.is_some() {
9222 return Err(serde::de::Error::duplicate_field("version"));
9223 }
9224 version__ = map_.next_value()?;
9225 }
9226 }
9227 }
9228 Ok(DropSourceResponse {
9229 status: status__,
9230 version: version__,
9231 })
9232 }
9233 }
9234 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9235 }
9236}
9237impl serde::Serialize for DropSubscriptionRequest {
9238 #[allow(deprecated)]
9239 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9240 where
9241 S: serde::Serializer,
9242 {
9243 use serde::ser::SerializeStruct;
9244 let mut len = 0;
9245 if self.subscription_id != 0 {
9246 len += 1;
9247 }
9248 if self.cascade {
9249 len += 1;
9250 }
9251 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9252 if self.subscription_id != 0 {
9253 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9254 }
9255 if self.cascade {
9256 struct_ser.serialize_field("cascade", &self.cascade)?;
9257 }
9258 struct_ser.end()
9259 }
9260}
9261impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9262 #[allow(deprecated)]
9263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9264 where
9265 D: serde::Deserializer<'de>,
9266 {
9267 const FIELDS: &[&str] = &[
9268 "subscription_id",
9269 "subscriptionId",
9270 "cascade",
9271 ];
9272
9273 #[allow(clippy::enum_variant_names)]
9274 enum GeneratedField {
9275 SubscriptionId,
9276 Cascade,
9277 }
9278 impl<'de> serde::Deserialize<'de> for GeneratedField {
9279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9280 where
9281 D: serde::Deserializer<'de>,
9282 {
9283 struct GeneratedVisitor;
9284
9285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9286 type Value = GeneratedField;
9287
9288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9289 write!(formatter, "expected one of: {:?}", &FIELDS)
9290 }
9291
9292 #[allow(unused_variables)]
9293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9294 where
9295 E: serde::de::Error,
9296 {
9297 match value {
9298 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9299 "cascade" => Ok(GeneratedField::Cascade),
9300 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9301 }
9302 }
9303 }
9304 deserializer.deserialize_identifier(GeneratedVisitor)
9305 }
9306 }
9307 struct GeneratedVisitor;
9308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9309 type Value = DropSubscriptionRequest;
9310
9311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9312 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9313 }
9314
9315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9316 where
9317 V: serde::de::MapAccess<'de>,
9318 {
9319 let mut subscription_id__ = None;
9320 let mut cascade__ = None;
9321 while let Some(k) = map_.next_key()? {
9322 match k {
9323 GeneratedField::SubscriptionId => {
9324 if subscription_id__.is_some() {
9325 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9326 }
9327 subscription_id__ =
9328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9329 ;
9330 }
9331 GeneratedField::Cascade => {
9332 if cascade__.is_some() {
9333 return Err(serde::de::Error::duplicate_field("cascade"));
9334 }
9335 cascade__ = Some(map_.next_value()?);
9336 }
9337 }
9338 }
9339 Ok(DropSubscriptionRequest {
9340 subscription_id: subscription_id__.unwrap_or_default(),
9341 cascade: cascade__.unwrap_or_default(),
9342 })
9343 }
9344 }
9345 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9346 }
9347}
9348impl serde::Serialize for DropSubscriptionResponse {
9349 #[allow(deprecated)]
9350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9351 where
9352 S: serde::Serializer,
9353 {
9354 use serde::ser::SerializeStruct;
9355 let mut len = 0;
9356 if self.status.is_some() {
9357 len += 1;
9358 }
9359 if self.version.is_some() {
9360 len += 1;
9361 }
9362 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9363 if let Some(v) = self.status.as_ref() {
9364 struct_ser.serialize_field("status", v)?;
9365 }
9366 if let Some(v) = self.version.as_ref() {
9367 struct_ser.serialize_field("version", v)?;
9368 }
9369 struct_ser.end()
9370 }
9371}
9372impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9373 #[allow(deprecated)]
9374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9375 where
9376 D: serde::Deserializer<'de>,
9377 {
9378 const FIELDS: &[&str] = &[
9379 "status",
9380 "version",
9381 ];
9382
9383 #[allow(clippy::enum_variant_names)]
9384 enum GeneratedField {
9385 Status,
9386 Version,
9387 }
9388 impl<'de> serde::Deserialize<'de> for GeneratedField {
9389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9390 where
9391 D: serde::Deserializer<'de>,
9392 {
9393 struct GeneratedVisitor;
9394
9395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9396 type Value = GeneratedField;
9397
9398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9399 write!(formatter, "expected one of: {:?}", &FIELDS)
9400 }
9401
9402 #[allow(unused_variables)]
9403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9404 where
9405 E: serde::de::Error,
9406 {
9407 match value {
9408 "status" => Ok(GeneratedField::Status),
9409 "version" => Ok(GeneratedField::Version),
9410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9411 }
9412 }
9413 }
9414 deserializer.deserialize_identifier(GeneratedVisitor)
9415 }
9416 }
9417 struct GeneratedVisitor;
9418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9419 type Value = DropSubscriptionResponse;
9420
9421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9422 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
9423 }
9424
9425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
9426 where
9427 V: serde::de::MapAccess<'de>,
9428 {
9429 let mut status__ = None;
9430 let mut version__ = None;
9431 while let Some(k) = map_.next_key()? {
9432 match k {
9433 GeneratedField::Status => {
9434 if status__.is_some() {
9435 return Err(serde::de::Error::duplicate_field("status"));
9436 }
9437 status__ = map_.next_value()?;
9438 }
9439 GeneratedField::Version => {
9440 if version__.is_some() {
9441 return Err(serde::de::Error::duplicate_field("version"));
9442 }
9443 version__ = map_.next_value()?;
9444 }
9445 }
9446 }
9447 Ok(DropSubscriptionResponse {
9448 status: status__,
9449 version: version__,
9450 })
9451 }
9452 }
9453 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
9454 }
9455}
9456impl serde::Serialize for DropTableRequest {
9457 #[allow(deprecated)]
9458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9459 where
9460 S: serde::Serializer,
9461 {
9462 use serde::ser::SerializeStruct;
9463 let mut len = 0;
9464 if self.table_id != 0 {
9465 len += 1;
9466 }
9467 if self.cascade {
9468 len += 1;
9469 }
9470 if self.source_id.is_some() {
9471 len += 1;
9472 }
9473 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
9474 if self.table_id != 0 {
9475 struct_ser.serialize_field("tableId", &self.table_id)?;
9476 }
9477 if self.cascade {
9478 struct_ser.serialize_field("cascade", &self.cascade)?;
9479 }
9480 if let Some(v) = self.source_id.as_ref() {
9481 match v {
9482 drop_table_request::SourceId::Id(v) => {
9483 struct_ser.serialize_field("id", v)?;
9484 }
9485 }
9486 }
9487 struct_ser.end()
9488 }
9489}
9490impl<'de> serde::Deserialize<'de> for DropTableRequest {
9491 #[allow(deprecated)]
9492 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9493 where
9494 D: serde::Deserializer<'de>,
9495 {
9496 const FIELDS: &[&str] = &[
9497 "table_id",
9498 "tableId",
9499 "cascade",
9500 "id",
9501 ];
9502
9503 #[allow(clippy::enum_variant_names)]
9504 enum GeneratedField {
9505 TableId,
9506 Cascade,
9507 Id,
9508 }
9509 impl<'de> serde::Deserialize<'de> for GeneratedField {
9510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511 where
9512 D: serde::Deserializer<'de>,
9513 {
9514 struct GeneratedVisitor;
9515
9516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517 type Value = GeneratedField;
9518
9519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520 write!(formatter, "expected one of: {:?}", &FIELDS)
9521 }
9522
9523 #[allow(unused_variables)]
9524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525 where
9526 E: serde::de::Error,
9527 {
9528 match value {
9529 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9530 "cascade" => Ok(GeneratedField::Cascade),
9531 "id" => Ok(GeneratedField::Id),
9532 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9533 }
9534 }
9535 }
9536 deserializer.deserialize_identifier(GeneratedVisitor)
9537 }
9538 }
9539 struct GeneratedVisitor;
9540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9541 type Value = DropTableRequest;
9542
9543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9544 formatter.write_str("struct ddl_service.DropTableRequest")
9545 }
9546
9547 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
9548 where
9549 V: serde::de::MapAccess<'de>,
9550 {
9551 let mut table_id__ = None;
9552 let mut cascade__ = None;
9553 let mut source_id__ = None;
9554 while let Some(k) = map_.next_key()? {
9555 match k {
9556 GeneratedField::TableId => {
9557 if table_id__.is_some() {
9558 return Err(serde::de::Error::duplicate_field("tableId"));
9559 }
9560 table_id__ =
9561 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9562 ;
9563 }
9564 GeneratedField::Cascade => {
9565 if cascade__.is_some() {
9566 return Err(serde::de::Error::duplicate_field("cascade"));
9567 }
9568 cascade__ = Some(map_.next_value()?);
9569 }
9570 GeneratedField::Id => {
9571 if source_id__.is_some() {
9572 return Err(serde::de::Error::duplicate_field("id"));
9573 }
9574 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
9575 }
9576 }
9577 }
9578 Ok(DropTableRequest {
9579 table_id: table_id__.unwrap_or_default(),
9580 cascade: cascade__.unwrap_or_default(),
9581 source_id: source_id__,
9582 })
9583 }
9584 }
9585 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
9586 }
9587}
9588impl serde::Serialize for DropTableResponse {
9589 #[allow(deprecated)]
9590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9591 where
9592 S: serde::Serializer,
9593 {
9594 use serde::ser::SerializeStruct;
9595 let mut len = 0;
9596 if self.status.is_some() {
9597 len += 1;
9598 }
9599 if self.version.is_some() {
9600 len += 1;
9601 }
9602 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
9603 if let Some(v) = self.status.as_ref() {
9604 struct_ser.serialize_field("status", v)?;
9605 }
9606 if let Some(v) = self.version.as_ref() {
9607 struct_ser.serialize_field("version", v)?;
9608 }
9609 struct_ser.end()
9610 }
9611}
9612impl<'de> serde::Deserialize<'de> for DropTableResponse {
9613 #[allow(deprecated)]
9614 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9615 where
9616 D: serde::Deserializer<'de>,
9617 {
9618 const FIELDS: &[&str] = &[
9619 "status",
9620 "version",
9621 ];
9622
9623 #[allow(clippy::enum_variant_names)]
9624 enum GeneratedField {
9625 Status,
9626 Version,
9627 }
9628 impl<'de> serde::Deserialize<'de> for GeneratedField {
9629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9630 where
9631 D: serde::Deserializer<'de>,
9632 {
9633 struct GeneratedVisitor;
9634
9635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9636 type Value = GeneratedField;
9637
9638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9639 write!(formatter, "expected one of: {:?}", &FIELDS)
9640 }
9641
9642 #[allow(unused_variables)]
9643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9644 where
9645 E: serde::de::Error,
9646 {
9647 match value {
9648 "status" => Ok(GeneratedField::Status),
9649 "version" => Ok(GeneratedField::Version),
9650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9651 }
9652 }
9653 }
9654 deserializer.deserialize_identifier(GeneratedVisitor)
9655 }
9656 }
9657 struct GeneratedVisitor;
9658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9659 type Value = DropTableResponse;
9660
9661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9662 formatter.write_str("struct ddl_service.DropTableResponse")
9663 }
9664
9665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
9666 where
9667 V: serde::de::MapAccess<'de>,
9668 {
9669 let mut status__ = None;
9670 let mut version__ = None;
9671 while let Some(k) = map_.next_key()? {
9672 match k {
9673 GeneratedField::Status => {
9674 if status__.is_some() {
9675 return Err(serde::de::Error::duplicate_field("status"));
9676 }
9677 status__ = map_.next_value()?;
9678 }
9679 GeneratedField::Version => {
9680 if version__.is_some() {
9681 return Err(serde::de::Error::duplicate_field("version"));
9682 }
9683 version__ = map_.next_value()?;
9684 }
9685 }
9686 }
9687 Ok(DropTableResponse {
9688 status: status__,
9689 version: version__,
9690 })
9691 }
9692 }
9693 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
9694 }
9695}
9696impl serde::Serialize for DropViewRequest {
9697 #[allow(deprecated)]
9698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9699 where
9700 S: serde::Serializer,
9701 {
9702 use serde::ser::SerializeStruct;
9703 let mut len = 0;
9704 if self.view_id != 0 {
9705 len += 1;
9706 }
9707 if self.cascade {
9708 len += 1;
9709 }
9710 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
9711 if self.view_id != 0 {
9712 struct_ser.serialize_field("viewId", &self.view_id)?;
9713 }
9714 if self.cascade {
9715 struct_ser.serialize_field("cascade", &self.cascade)?;
9716 }
9717 struct_ser.end()
9718 }
9719}
9720impl<'de> serde::Deserialize<'de> for DropViewRequest {
9721 #[allow(deprecated)]
9722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9723 where
9724 D: serde::Deserializer<'de>,
9725 {
9726 const FIELDS: &[&str] = &[
9727 "view_id",
9728 "viewId",
9729 "cascade",
9730 ];
9731
9732 #[allow(clippy::enum_variant_names)]
9733 enum GeneratedField {
9734 ViewId,
9735 Cascade,
9736 }
9737 impl<'de> serde::Deserialize<'de> for GeneratedField {
9738 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9739 where
9740 D: serde::Deserializer<'de>,
9741 {
9742 struct GeneratedVisitor;
9743
9744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9745 type Value = GeneratedField;
9746
9747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9748 write!(formatter, "expected one of: {:?}", &FIELDS)
9749 }
9750
9751 #[allow(unused_variables)]
9752 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9753 where
9754 E: serde::de::Error,
9755 {
9756 match value {
9757 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
9758 "cascade" => Ok(GeneratedField::Cascade),
9759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9760 }
9761 }
9762 }
9763 deserializer.deserialize_identifier(GeneratedVisitor)
9764 }
9765 }
9766 struct GeneratedVisitor;
9767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9768 type Value = DropViewRequest;
9769
9770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9771 formatter.write_str("struct ddl_service.DropViewRequest")
9772 }
9773
9774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
9775 where
9776 V: serde::de::MapAccess<'de>,
9777 {
9778 let mut view_id__ = None;
9779 let mut cascade__ = None;
9780 while let Some(k) = map_.next_key()? {
9781 match k {
9782 GeneratedField::ViewId => {
9783 if view_id__.is_some() {
9784 return Err(serde::de::Error::duplicate_field("viewId"));
9785 }
9786 view_id__ =
9787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9788 ;
9789 }
9790 GeneratedField::Cascade => {
9791 if cascade__.is_some() {
9792 return Err(serde::de::Error::duplicate_field("cascade"));
9793 }
9794 cascade__ = Some(map_.next_value()?);
9795 }
9796 }
9797 }
9798 Ok(DropViewRequest {
9799 view_id: view_id__.unwrap_or_default(),
9800 cascade: cascade__.unwrap_or_default(),
9801 })
9802 }
9803 }
9804 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
9805 }
9806}
9807impl serde::Serialize for DropViewResponse {
9808 #[allow(deprecated)]
9809 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9810 where
9811 S: serde::Serializer,
9812 {
9813 use serde::ser::SerializeStruct;
9814 let mut len = 0;
9815 if self.status.is_some() {
9816 len += 1;
9817 }
9818 if self.version.is_some() {
9819 len += 1;
9820 }
9821 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
9822 if let Some(v) = self.status.as_ref() {
9823 struct_ser.serialize_field("status", v)?;
9824 }
9825 if let Some(v) = self.version.as_ref() {
9826 struct_ser.serialize_field("version", v)?;
9827 }
9828 struct_ser.end()
9829 }
9830}
9831impl<'de> serde::Deserialize<'de> for DropViewResponse {
9832 #[allow(deprecated)]
9833 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9834 where
9835 D: serde::Deserializer<'de>,
9836 {
9837 const FIELDS: &[&str] = &[
9838 "status",
9839 "version",
9840 ];
9841
9842 #[allow(clippy::enum_variant_names)]
9843 enum GeneratedField {
9844 Status,
9845 Version,
9846 }
9847 impl<'de> serde::Deserialize<'de> for GeneratedField {
9848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9849 where
9850 D: serde::Deserializer<'de>,
9851 {
9852 struct GeneratedVisitor;
9853
9854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9855 type Value = GeneratedField;
9856
9857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9858 write!(formatter, "expected one of: {:?}", &FIELDS)
9859 }
9860
9861 #[allow(unused_variables)]
9862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9863 where
9864 E: serde::de::Error,
9865 {
9866 match value {
9867 "status" => Ok(GeneratedField::Status),
9868 "version" => Ok(GeneratedField::Version),
9869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9870 }
9871 }
9872 }
9873 deserializer.deserialize_identifier(GeneratedVisitor)
9874 }
9875 }
9876 struct GeneratedVisitor;
9877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9878 type Value = DropViewResponse;
9879
9880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9881 formatter.write_str("struct ddl_service.DropViewResponse")
9882 }
9883
9884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
9885 where
9886 V: serde::de::MapAccess<'de>,
9887 {
9888 let mut status__ = None;
9889 let mut version__ = None;
9890 while let Some(k) = map_.next_key()? {
9891 match k {
9892 GeneratedField::Status => {
9893 if status__.is_some() {
9894 return Err(serde::de::Error::duplicate_field("status"));
9895 }
9896 status__ = map_.next_value()?;
9897 }
9898 GeneratedField::Version => {
9899 if version__.is_some() {
9900 return Err(serde::de::Error::duplicate_field("version"));
9901 }
9902 version__ = map_.next_value()?;
9903 }
9904 }
9905 }
9906 Ok(DropViewResponse {
9907 status: status__,
9908 version: version__,
9909 })
9910 }
9911 }
9912 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
9913 }
9914}
9915impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
9916 #[allow(deprecated)]
9917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9918 where
9919 S: serde::Serializer,
9920 {
9921 use serde::ser::SerializeStruct;
9922 let mut len = 0;
9923 if self.sink_id != 0 {
9924 len += 1;
9925 }
9926 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
9927 if self.sink_id != 0 {
9928 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9929 }
9930 struct_ser.end()
9931 }
9932}
9933impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
9934 #[allow(deprecated)]
9935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9936 where
9937 D: serde::Deserializer<'de>,
9938 {
9939 const FIELDS: &[&str] = &[
9940 "sink_id",
9941 "sinkId",
9942 ];
9943
9944 #[allow(clippy::enum_variant_names)]
9945 enum GeneratedField {
9946 SinkId,
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<'de> serde::de::Visitor<'de> 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 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9969 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9970 }
9971 }
9972 }
9973 deserializer.deserialize_identifier(GeneratedVisitor)
9974 }
9975 }
9976 struct GeneratedVisitor;
9977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9978 type Value = ExpireIcebergTableSnapshotsRequest;
9979
9980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9981 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
9982 }
9983
9984 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
9985 where
9986 V: serde::de::MapAccess<'de>,
9987 {
9988 let mut sink_id__ = None;
9989 while let Some(k) = map_.next_key()? {
9990 match k {
9991 GeneratedField::SinkId => {
9992 if sink_id__.is_some() {
9993 return Err(serde::de::Error::duplicate_field("sinkId"));
9994 }
9995 sink_id__ =
9996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9997 ;
9998 }
9999 }
10000 }
10001 Ok(ExpireIcebergTableSnapshotsRequest {
10002 sink_id: sink_id__.unwrap_or_default(),
10003 })
10004 }
10005 }
10006 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
10007 }
10008}
10009impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
10010 #[allow(deprecated)]
10011 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10012 where
10013 S: serde::Serializer,
10014 {
10015 use serde::ser::SerializeStruct;
10016 let mut len = 0;
10017 if self.status.is_some() {
10018 len += 1;
10019 }
10020 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
10021 if let Some(v) = self.status.as_ref() {
10022 struct_ser.serialize_field("status", v)?;
10023 }
10024 struct_ser.end()
10025 }
10026}
10027impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
10028 #[allow(deprecated)]
10029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10030 where
10031 D: serde::Deserializer<'de>,
10032 {
10033 const FIELDS: &[&str] = &[
10034 "status",
10035 ];
10036
10037 #[allow(clippy::enum_variant_names)]
10038 enum GeneratedField {
10039 Status,
10040 }
10041 impl<'de> serde::Deserialize<'de> for GeneratedField {
10042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10043 where
10044 D: serde::Deserializer<'de>,
10045 {
10046 struct GeneratedVisitor;
10047
10048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10049 type Value = GeneratedField;
10050
10051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10052 write!(formatter, "expected one of: {:?}", &FIELDS)
10053 }
10054
10055 #[allow(unused_variables)]
10056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10057 where
10058 E: serde::de::Error,
10059 {
10060 match value {
10061 "status" => Ok(GeneratedField::Status),
10062 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10063 }
10064 }
10065 }
10066 deserializer.deserialize_identifier(GeneratedVisitor)
10067 }
10068 }
10069 struct GeneratedVisitor;
10070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10071 type Value = ExpireIcebergTableSnapshotsResponse;
10072
10073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10074 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
10075 }
10076
10077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
10078 where
10079 V: serde::de::MapAccess<'de>,
10080 {
10081 let mut status__ = None;
10082 while let Some(k) = map_.next_key()? {
10083 match k {
10084 GeneratedField::Status => {
10085 if status__.is_some() {
10086 return Err(serde::de::Error::duplicate_field("status"));
10087 }
10088 status__ = map_.next_value()?;
10089 }
10090 }
10091 }
10092 Ok(ExpireIcebergTableSnapshotsResponse {
10093 status: status__,
10094 })
10095 }
10096 }
10097 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
10098 }
10099}
10100impl serde::Serialize for GetDdlProgressRequest {
10101 #[allow(deprecated)]
10102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10103 where
10104 S: serde::Serializer,
10105 {
10106 use serde::ser::SerializeStruct;
10107 let len = 0;
10108 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
10109 struct_ser.end()
10110 }
10111}
10112impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
10113 #[allow(deprecated)]
10114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10115 where
10116 D: serde::Deserializer<'de>,
10117 {
10118 const FIELDS: &[&str] = &[
10119 ];
10120
10121 #[allow(clippy::enum_variant_names)]
10122 enum GeneratedField {
10123 }
10124 impl<'de> serde::Deserialize<'de> for GeneratedField {
10125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10126 where
10127 D: serde::Deserializer<'de>,
10128 {
10129 struct GeneratedVisitor;
10130
10131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10132 type Value = GeneratedField;
10133
10134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10135 write!(formatter, "expected one of: {:?}", &FIELDS)
10136 }
10137
10138 #[allow(unused_variables)]
10139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10140 where
10141 E: serde::de::Error,
10142 {
10143 Err(serde::de::Error::unknown_field(value, FIELDS))
10144 }
10145 }
10146 deserializer.deserialize_identifier(GeneratedVisitor)
10147 }
10148 }
10149 struct GeneratedVisitor;
10150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10151 type Value = GetDdlProgressRequest;
10152
10153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10154 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
10155 }
10156
10157 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
10158 where
10159 V: serde::de::MapAccess<'de>,
10160 {
10161 while map_.next_key::<GeneratedField>()?.is_some() {
10162 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10163 }
10164 Ok(GetDdlProgressRequest {
10165 })
10166 }
10167 }
10168 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
10169 }
10170}
10171impl serde::Serialize for GetDdlProgressResponse {
10172 #[allow(deprecated)]
10173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10174 where
10175 S: serde::Serializer,
10176 {
10177 use serde::ser::SerializeStruct;
10178 let mut len = 0;
10179 if !self.ddl_progress.is_empty() {
10180 len += 1;
10181 }
10182 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
10183 if !self.ddl_progress.is_empty() {
10184 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
10185 }
10186 struct_ser.end()
10187 }
10188}
10189impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
10190 #[allow(deprecated)]
10191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10192 where
10193 D: serde::Deserializer<'de>,
10194 {
10195 const FIELDS: &[&str] = &[
10196 "ddl_progress",
10197 "ddlProgress",
10198 ];
10199
10200 #[allow(clippy::enum_variant_names)]
10201 enum GeneratedField {
10202 DdlProgress,
10203 }
10204 impl<'de> serde::Deserialize<'de> for GeneratedField {
10205 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10206 where
10207 D: serde::Deserializer<'de>,
10208 {
10209 struct GeneratedVisitor;
10210
10211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10212 type Value = GeneratedField;
10213
10214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10215 write!(formatter, "expected one of: {:?}", &FIELDS)
10216 }
10217
10218 #[allow(unused_variables)]
10219 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10220 where
10221 E: serde::de::Error,
10222 {
10223 match value {
10224 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10226 }
10227 }
10228 }
10229 deserializer.deserialize_identifier(GeneratedVisitor)
10230 }
10231 }
10232 struct GeneratedVisitor;
10233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10234 type Value = GetDdlProgressResponse;
10235
10236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10237 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10238 }
10239
10240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10241 where
10242 V: serde::de::MapAccess<'de>,
10243 {
10244 let mut ddl_progress__ = None;
10245 while let Some(k) = map_.next_key()? {
10246 match k {
10247 GeneratedField::DdlProgress => {
10248 if ddl_progress__.is_some() {
10249 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10250 }
10251 ddl_progress__ = Some(map_.next_value()?);
10252 }
10253 }
10254 }
10255 Ok(GetDdlProgressResponse {
10256 ddl_progress: ddl_progress__.unwrap_or_default(),
10257 })
10258 }
10259 }
10260 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10261 }
10262}
10263impl serde::Serialize for GetTableRequest {
10264 #[allow(deprecated)]
10265 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10266 where
10267 S: serde::Serializer,
10268 {
10269 use serde::ser::SerializeStruct;
10270 let mut len = 0;
10271 if !self.database_name.is_empty() {
10272 len += 1;
10273 }
10274 if !self.table_name.is_empty() {
10275 len += 1;
10276 }
10277 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10278 if !self.database_name.is_empty() {
10279 struct_ser.serialize_field("databaseName", &self.database_name)?;
10280 }
10281 if !self.table_name.is_empty() {
10282 struct_ser.serialize_field("tableName", &self.table_name)?;
10283 }
10284 struct_ser.end()
10285 }
10286}
10287impl<'de> serde::Deserialize<'de> for GetTableRequest {
10288 #[allow(deprecated)]
10289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10290 where
10291 D: serde::Deserializer<'de>,
10292 {
10293 const FIELDS: &[&str] = &[
10294 "database_name",
10295 "databaseName",
10296 "table_name",
10297 "tableName",
10298 ];
10299
10300 #[allow(clippy::enum_variant_names)]
10301 enum GeneratedField {
10302 DatabaseName,
10303 TableName,
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<'de> serde::de::Visitor<'de> 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 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10326 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10328 }
10329 }
10330 }
10331 deserializer.deserialize_identifier(GeneratedVisitor)
10332 }
10333 }
10334 struct GeneratedVisitor;
10335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10336 type Value = GetTableRequest;
10337
10338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10339 formatter.write_str("struct ddl_service.GetTableRequest")
10340 }
10341
10342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10343 where
10344 V: serde::de::MapAccess<'de>,
10345 {
10346 let mut database_name__ = None;
10347 let mut table_name__ = None;
10348 while let Some(k) = map_.next_key()? {
10349 match k {
10350 GeneratedField::DatabaseName => {
10351 if database_name__.is_some() {
10352 return Err(serde::de::Error::duplicate_field("databaseName"));
10353 }
10354 database_name__ = Some(map_.next_value()?);
10355 }
10356 GeneratedField::TableName => {
10357 if table_name__.is_some() {
10358 return Err(serde::de::Error::duplicate_field("tableName"));
10359 }
10360 table_name__ = Some(map_.next_value()?);
10361 }
10362 }
10363 }
10364 Ok(GetTableRequest {
10365 database_name: database_name__.unwrap_or_default(),
10366 table_name: table_name__.unwrap_or_default(),
10367 })
10368 }
10369 }
10370 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10371 }
10372}
10373impl serde::Serialize for GetTableResponse {
10374 #[allow(deprecated)]
10375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10376 where
10377 S: serde::Serializer,
10378 {
10379 use serde::ser::SerializeStruct;
10380 let mut len = 0;
10381 if self.table.is_some() {
10382 len += 1;
10383 }
10384 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10385 if let Some(v) = self.table.as_ref() {
10386 struct_ser.serialize_field("table", v)?;
10387 }
10388 struct_ser.end()
10389 }
10390}
10391impl<'de> serde::Deserialize<'de> for GetTableResponse {
10392 #[allow(deprecated)]
10393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10394 where
10395 D: serde::Deserializer<'de>,
10396 {
10397 const FIELDS: &[&str] = &[
10398 "table",
10399 ];
10400
10401 #[allow(clippy::enum_variant_names)]
10402 enum GeneratedField {
10403 Table,
10404 }
10405 impl<'de> serde::Deserialize<'de> for GeneratedField {
10406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10407 where
10408 D: serde::Deserializer<'de>,
10409 {
10410 struct GeneratedVisitor;
10411
10412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10413 type Value = GeneratedField;
10414
10415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10416 write!(formatter, "expected one of: {:?}", &FIELDS)
10417 }
10418
10419 #[allow(unused_variables)]
10420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10421 where
10422 E: serde::de::Error,
10423 {
10424 match value {
10425 "table" => Ok(GeneratedField::Table),
10426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10427 }
10428 }
10429 }
10430 deserializer.deserialize_identifier(GeneratedVisitor)
10431 }
10432 }
10433 struct GeneratedVisitor;
10434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10435 type Value = GetTableResponse;
10436
10437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10438 formatter.write_str("struct ddl_service.GetTableResponse")
10439 }
10440
10441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
10442 where
10443 V: serde::de::MapAccess<'de>,
10444 {
10445 let mut table__ = None;
10446 while let Some(k) = map_.next_key()? {
10447 match k {
10448 GeneratedField::Table => {
10449 if table__.is_some() {
10450 return Err(serde::de::Error::duplicate_field("table"));
10451 }
10452 table__ = map_.next_value()?;
10453 }
10454 }
10455 }
10456 Ok(GetTableResponse {
10457 table: table__,
10458 })
10459 }
10460 }
10461 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
10462 }
10463}
10464impl serde::Serialize for GetTablesRequest {
10465 #[allow(deprecated)]
10466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10467 where
10468 S: serde::Serializer,
10469 {
10470 use serde::ser::SerializeStruct;
10471 let mut len = 0;
10472 if !self.table_ids.is_empty() {
10473 len += 1;
10474 }
10475 if self.include_dropped_tables {
10476 len += 1;
10477 }
10478 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
10479 if !self.table_ids.is_empty() {
10480 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10481 }
10482 if self.include_dropped_tables {
10483 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
10484 }
10485 struct_ser.end()
10486 }
10487}
10488impl<'de> serde::Deserialize<'de> for GetTablesRequest {
10489 #[allow(deprecated)]
10490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10491 where
10492 D: serde::Deserializer<'de>,
10493 {
10494 const FIELDS: &[&str] = &[
10495 "table_ids",
10496 "tableIds",
10497 "include_dropped_tables",
10498 "includeDroppedTables",
10499 ];
10500
10501 #[allow(clippy::enum_variant_names)]
10502 enum GeneratedField {
10503 TableIds,
10504 IncludeDroppedTables,
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<'de> serde::de::Visitor<'de> 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 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10527 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
10528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10529 }
10530 }
10531 }
10532 deserializer.deserialize_identifier(GeneratedVisitor)
10533 }
10534 }
10535 struct GeneratedVisitor;
10536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10537 type Value = GetTablesRequest;
10538
10539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10540 formatter.write_str("struct ddl_service.GetTablesRequest")
10541 }
10542
10543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
10544 where
10545 V: serde::de::MapAccess<'de>,
10546 {
10547 let mut table_ids__ = None;
10548 let mut include_dropped_tables__ = None;
10549 while let Some(k) = map_.next_key()? {
10550 match k {
10551 GeneratedField::TableIds => {
10552 if table_ids__.is_some() {
10553 return Err(serde::de::Error::duplicate_field("tableIds"));
10554 }
10555 table_ids__ =
10556 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10557 .into_iter().map(|x| x.0).collect())
10558 ;
10559 }
10560 GeneratedField::IncludeDroppedTables => {
10561 if include_dropped_tables__.is_some() {
10562 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
10563 }
10564 include_dropped_tables__ = Some(map_.next_value()?);
10565 }
10566 }
10567 }
10568 Ok(GetTablesRequest {
10569 table_ids: table_ids__.unwrap_or_default(),
10570 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
10571 })
10572 }
10573 }
10574 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
10575 }
10576}
10577impl serde::Serialize for GetTablesResponse {
10578 #[allow(deprecated)]
10579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10580 where
10581 S: serde::Serializer,
10582 {
10583 use serde::ser::SerializeStruct;
10584 let mut len = 0;
10585 if !self.tables.is_empty() {
10586 len += 1;
10587 }
10588 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
10589 if !self.tables.is_empty() {
10590 struct_ser.serialize_field("tables", &self.tables)?;
10591 }
10592 struct_ser.end()
10593 }
10594}
10595impl<'de> serde::Deserialize<'de> for GetTablesResponse {
10596 #[allow(deprecated)]
10597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10598 where
10599 D: serde::Deserializer<'de>,
10600 {
10601 const FIELDS: &[&str] = &[
10602 "tables",
10603 ];
10604
10605 #[allow(clippy::enum_variant_names)]
10606 enum GeneratedField {
10607 Tables,
10608 }
10609 impl<'de> serde::Deserialize<'de> for GeneratedField {
10610 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10611 where
10612 D: serde::Deserializer<'de>,
10613 {
10614 struct GeneratedVisitor;
10615
10616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10617 type Value = GeneratedField;
10618
10619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10620 write!(formatter, "expected one of: {:?}", &FIELDS)
10621 }
10622
10623 #[allow(unused_variables)]
10624 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10625 where
10626 E: serde::de::Error,
10627 {
10628 match value {
10629 "tables" => Ok(GeneratedField::Tables),
10630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10631 }
10632 }
10633 }
10634 deserializer.deserialize_identifier(GeneratedVisitor)
10635 }
10636 }
10637 struct GeneratedVisitor;
10638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10639 type Value = GetTablesResponse;
10640
10641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10642 formatter.write_str("struct ddl_service.GetTablesResponse")
10643 }
10644
10645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
10646 where
10647 V: serde::de::MapAccess<'de>,
10648 {
10649 let mut tables__ = None;
10650 while let Some(k) = map_.next_key()? {
10651 match k {
10652 GeneratedField::Tables => {
10653 if tables__.is_some() {
10654 return Err(serde::de::Error::duplicate_field("tables"));
10655 }
10656 tables__ = Some(
10657 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10658 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10659 );
10660 }
10661 }
10662 }
10663 Ok(GetTablesResponse {
10664 tables: tables__.unwrap_or_default(),
10665 })
10666 }
10667 }
10668 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
10669 }
10670}
10671impl serde::Serialize for ListConnectionsRequest {
10672 #[allow(deprecated)]
10673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10674 where
10675 S: serde::Serializer,
10676 {
10677 use serde::ser::SerializeStruct;
10678 let len = 0;
10679 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
10680 struct_ser.end()
10681 }
10682}
10683impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
10684 #[allow(deprecated)]
10685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10686 where
10687 D: serde::Deserializer<'de>,
10688 {
10689 const FIELDS: &[&str] = &[
10690 ];
10691
10692 #[allow(clippy::enum_variant_names)]
10693 enum GeneratedField {
10694 }
10695 impl<'de> serde::Deserialize<'de> for GeneratedField {
10696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10697 where
10698 D: serde::Deserializer<'de>,
10699 {
10700 struct GeneratedVisitor;
10701
10702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10703 type Value = GeneratedField;
10704
10705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10706 write!(formatter, "expected one of: {:?}", &FIELDS)
10707 }
10708
10709 #[allow(unused_variables)]
10710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10711 where
10712 E: serde::de::Error,
10713 {
10714 Err(serde::de::Error::unknown_field(value, FIELDS))
10715 }
10716 }
10717 deserializer.deserialize_identifier(GeneratedVisitor)
10718 }
10719 }
10720 struct GeneratedVisitor;
10721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10722 type Value = ListConnectionsRequest;
10723
10724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10725 formatter.write_str("struct ddl_service.ListConnectionsRequest")
10726 }
10727
10728 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
10729 where
10730 V: serde::de::MapAccess<'de>,
10731 {
10732 while map_.next_key::<GeneratedField>()?.is_some() {
10733 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10734 }
10735 Ok(ListConnectionsRequest {
10736 })
10737 }
10738 }
10739 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
10740 }
10741}
10742impl serde::Serialize for ListConnectionsResponse {
10743 #[allow(deprecated)]
10744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10745 where
10746 S: serde::Serializer,
10747 {
10748 use serde::ser::SerializeStruct;
10749 let mut len = 0;
10750 if !self.connections.is_empty() {
10751 len += 1;
10752 }
10753 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
10754 if !self.connections.is_empty() {
10755 struct_ser.serialize_field("connections", &self.connections)?;
10756 }
10757 struct_ser.end()
10758 }
10759}
10760impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
10761 #[allow(deprecated)]
10762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10763 where
10764 D: serde::Deserializer<'de>,
10765 {
10766 const FIELDS: &[&str] = &[
10767 "connections",
10768 ];
10769
10770 #[allow(clippy::enum_variant_names)]
10771 enum GeneratedField {
10772 Connections,
10773 }
10774 impl<'de> serde::Deserialize<'de> for GeneratedField {
10775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10776 where
10777 D: serde::Deserializer<'de>,
10778 {
10779 struct GeneratedVisitor;
10780
10781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10782 type Value = GeneratedField;
10783
10784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10785 write!(formatter, "expected one of: {:?}", &FIELDS)
10786 }
10787
10788 #[allow(unused_variables)]
10789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10790 where
10791 E: serde::de::Error,
10792 {
10793 match value {
10794 "connections" => Ok(GeneratedField::Connections),
10795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10796 }
10797 }
10798 }
10799 deserializer.deserialize_identifier(GeneratedVisitor)
10800 }
10801 }
10802 struct GeneratedVisitor;
10803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10804 type Value = ListConnectionsResponse;
10805
10806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10807 formatter.write_str("struct ddl_service.ListConnectionsResponse")
10808 }
10809
10810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
10811 where
10812 V: serde::de::MapAccess<'de>,
10813 {
10814 let mut connections__ = None;
10815 while let Some(k) = map_.next_key()? {
10816 match k {
10817 GeneratedField::Connections => {
10818 if connections__.is_some() {
10819 return Err(serde::de::Error::duplicate_field("connections"));
10820 }
10821 connections__ = Some(map_.next_value()?);
10822 }
10823 }
10824 }
10825 Ok(ListConnectionsResponse {
10826 connections: connections__.unwrap_or_default(),
10827 })
10828 }
10829 }
10830 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
10831 }
10832}
10833impl serde::Serialize for ReplaceJobPlan {
10834 #[allow(deprecated)]
10835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10836 where
10837 S: serde::Serializer,
10838 {
10839 use serde::ser::SerializeStruct;
10840 let mut len = 0;
10841 if self.fragment_graph.is_some() {
10842 len += 1;
10843 }
10844 if self.replace_job.is_some() {
10845 len += 1;
10846 }
10847 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
10848 if let Some(v) = self.fragment_graph.as_ref() {
10849 struct_ser.serialize_field("fragmentGraph", v)?;
10850 }
10851 if let Some(v) = self.replace_job.as_ref() {
10852 match v {
10853 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
10854 struct_ser.serialize_field("replaceTable", v)?;
10855 }
10856 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
10857 struct_ser.serialize_field("replaceSource", v)?;
10858 }
10859 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
10860 struct_ser.serialize_field("replaceMaterializedView", v)?;
10861 }
10862 }
10863 }
10864 struct_ser.end()
10865 }
10866}
10867impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
10868 #[allow(deprecated)]
10869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10870 where
10871 D: serde::Deserializer<'de>,
10872 {
10873 const FIELDS: &[&str] = &[
10874 "fragment_graph",
10875 "fragmentGraph",
10876 "replace_table",
10877 "replaceTable",
10878 "replace_source",
10879 "replaceSource",
10880 "replace_materialized_view",
10881 "replaceMaterializedView",
10882 ];
10883
10884 #[allow(clippy::enum_variant_names)]
10885 enum GeneratedField {
10886 FragmentGraph,
10887 ReplaceTable,
10888 ReplaceSource,
10889 ReplaceMaterializedView,
10890 }
10891 impl<'de> serde::Deserialize<'de> for GeneratedField {
10892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10893 where
10894 D: serde::Deserializer<'de>,
10895 {
10896 struct GeneratedVisitor;
10897
10898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10899 type Value = GeneratedField;
10900
10901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10902 write!(formatter, "expected one of: {:?}", &FIELDS)
10903 }
10904
10905 #[allow(unused_variables)]
10906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10907 where
10908 E: serde::de::Error,
10909 {
10910 match value {
10911 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
10912 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
10913 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
10914 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
10915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10916 }
10917 }
10918 }
10919 deserializer.deserialize_identifier(GeneratedVisitor)
10920 }
10921 }
10922 struct GeneratedVisitor;
10923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10924 type Value = ReplaceJobPlan;
10925
10926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10927 formatter.write_str("struct ddl_service.ReplaceJobPlan")
10928 }
10929
10930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
10931 where
10932 V: serde::de::MapAccess<'de>,
10933 {
10934 let mut fragment_graph__ = None;
10935 let mut replace_job__ = None;
10936 while let Some(k) = map_.next_key()? {
10937 match k {
10938 GeneratedField::FragmentGraph => {
10939 if fragment_graph__.is_some() {
10940 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
10941 }
10942 fragment_graph__ = map_.next_value()?;
10943 }
10944 GeneratedField::ReplaceTable => {
10945 if replace_job__.is_some() {
10946 return Err(serde::de::Error::duplicate_field("replaceTable"));
10947 }
10948 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
10949;
10950 }
10951 GeneratedField::ReplaceSource => {
10952 if replace_job__.is_some() {
10953 return Err(serde::de::Error::duplicate_field("replaceSource"));
10954 }
10955 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
10956;
10957 }
10958 GeneratedField::ReplaceMaterializedView => {
10959 if replace_job__.is_some() {
10960 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
10961 }
10962 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
10963;
10964 }
10965 }
10966 }
10967 Ok(ReplaceJobPlan {
10968 fragment_graph: fragment_graph__,
10969 replace_job: replace_job__,
10970 })
10971 }
10972 }
10973 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
10974 }
10975}
10976impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
10977 #[allow(deprecated)]
10978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10979 where
10980 S: serde::Serializer,
10981 {
10982 use serde::ser::SerializeStruct;
10983 let mut len = 0;
10984 if self.table.is_some() {
10985 len += 1;
10986 }
10987 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
10988 if let Some(v) = self.table.as_ref() {
10989 struct_ser.serialize_field("table", v)?;
10990 }
10991 struct_ser.end()
10992 }
10993}
10994impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
10995 #[allow(deprecated)]
10996 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10997 where
10998 D: serde::Deserializer<'de>,
10999 {
11000 const FIELDS: &[&str] = &[
11001 "table",
11002 ];
11003
11004 #[allow(clippy::enum_variant_names)]
11005 enum GeneratedField {
11006 Table,
11007 }
11008 impl<'de> serde::Deserialize<'de> for GeneratedField {
11009 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11010 where
11011 D: serde::Deserializer<'de>,
11012 {
11013 struct GeneratedVisitor;
11014
11015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11016 type Value = GeneratedField;
11017
11018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11019 write!(formatter, "expected one of: {:?}", &FIELDS)
11020 }
11021
11022 #[allow(unused_variables)]
11023 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11024 where
11025 E: serde::de::Error,
11026 {
11027 match value {
11028 "table" => Ok(GeneratedField::Table),
11029 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11030 }
11031 }
11032 }
11033 deserializer.deserialize_identifier(GeneratedVisitor)
11034 }
11035 }
11036 struct GeneratedVisitor;
11037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11038 type Value = replace_job_plan::ReplaceMaterializedView;
11039
11040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11041 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
11042 }
11043
11044 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
11045 where
11046 V: serde::de::MapAccess<'de>,
11047 {
11048 let mut table__ = None;
11049 while let Some(k) = map_.next_key()? {
11050 match k {
11051 GeneratedField::Table => {
11052 if table__.is_some() {
11053 return Err(serde::de::Error::duplicate_field("table"));
11054 }
11055 table__ = map_.next_value()?;
11056 }
11057 }
11058 }
11059 Ok(replace_job_plan::ReplaceMaterializedView {
11060 table: table__,
11061 })
11062 }
11063 }
11064 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
11065 }
11066}
11067impl serde::Serialize for replace_job_plan::ReplaceSource {
11068 #[allow(deprecated)]
11069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11070 where
11071 S: serde::Serializer,
11072 {
11073 use serde::ser::SerializeStruct;
11074 let mut len = 0;
11075 if self.source.is_some() {
11076 len += 1;
11077 }
11078 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
11079 if let Some(v) = self.source.as_ref() {
11080 struct_ser.serialize_field("source", v)?;
11081 }
11082 struct_ser.end()
11083 }
11084}
11085impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
11086 #[allow(deprecated)]
11087 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11088 where
11089 D: serde::Deserializer<'de>,
11090 {
11091 const FIELDS: &[&str] = &[
11092 "source",
11093 ];
11094
11095 #[allow(clippy::enum_variant_names)]
11096 enum GeneratedField {
11097 Source,
11098 }
11099 impl<'de> serde::Deserialize<'de> for GeneratedField {
11100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11101 where
11102 D: serde::Deserializer<'de>,
11103 {
11104 struct GeneratedVisitor;
11105
11106 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11107 type Value = GeneratedField;
11108
11109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11110 write!(formatter, "expected one of: {:?}", &FIELDS)
11111 }
11112
11113 #[allow(unused_variables)]
11114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11115 where
11116 E: serde::de::Error,
11117 {
11118 match value {
11119 "source" => Ok(GeneratedField::Source),
11120 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11121 }
11122 }
11123 }
11124 deserializer.deserialize_identifier(GeneratedVisitor)
11125 }
11126 }
11127 struct GeneratedVisitor;
11128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11129 type Value = replace_job_plan::ReplaceSource;
11130
11131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11132 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
11133 }
11134
11135 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
11136 where
11137 V: serde::de::MapAccess<'de>,
11138 {
11139 let mut source__ = None;
11140 while let Some(k) = map_.next_key()? {
11141 match k {
11142 GeneratedField::Source => {
11143 if source__.is_some() {
11144 return Err(serde::de::Error::duplicate_field("source"));
11145 }
11146 source__ = map_.next_value()?;
11147 }
11148 }
11149 }
11150 Ok(replace_job_plan::ReplaceSource {
11151 source: source__,
11152 })
11153 }
11154 }
11155 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
11156 }
11157}
11158impl serde::Serialize for replace_job_plan::ReplaceTable {
11159 #[allow(deprecated)]
11160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11161 where
11162 S: serde::Serializer,
11163 {
11164 use serde::ser::SerializeStruct;
11165 let mut len = 0;
11166 if self.table.is_some() {
11167 len += 1;
11168 }
11169 if self.source.is_some() {
11170 len += 1;
11171 }
11172 if self.job_type != 0 {
11173 len += 1;
11174 }
11175 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
11176 if let Some(v) = self.table.as_ref() {
11177 struct_ser.serialize_field("table", v)?;
11178 }
11179 if let Some(v) = self.source.as_ref() {
11180 struct_ser.serialize_field("source", v)?;
11181 }
11182 if self.job_type != 0 {
11183 let v = TableJobType::try_from(self.job_type)
11184 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
11185 struct_ser.serialize_field("jobType", &v)?;
11186 }
11187 struct_ser.end()
11188 }
11189}
11190impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
11191 #[allow(deprecated)]
11192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11193 where
11194 D: serde::Deserializer<'de>,
11195 {
11196 const FIELDS: &[&str] = &[
11197 "table",
11198 "source",
11199 "job_type",
11200 "jobType",
11201 ];
11202
11203 #[allow(clippy::enum_variant_names)]
11204 enum GeneratedField {
11205 Table,
11206 Source,
11207 JobType,
11208 }
11209 impl<'de> serde::Deserialize<'de> for GeneratedField {
11210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11211 where
11212 D: serde::Deserializer<'de>,
11213 {
11214 struct GeneratedVisitor;
11215
11216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11217 type Value = GeneratedField;
11218
11219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11220 write!(formatter, "expected one of: {:?}", &FIELDS)
11221 }
11222
11223 #[allow(unused_variables)]
11224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11225 where
11226 E: serde::de::Error,
11227 {
11228 match value {
11229 "table" => Ok(GeneratedField::Table),
11230 "source" => Ok(GeneratedField::Source),
11231 "jobType" | "job_type" => Ok(GeneratedField::JobType),
11232 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11233 }
11234 }
11235 }
11236 deserializer.deserialize_identifier(GeneratedVisitor)
11237 }
11238 }
11239 struct GeneratedVisitor;
11240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11241 type Value = replace_job_plan::ReplaceTable;
11242
11243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11244 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11245 }
11246
11247 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11248 where
11249 V: serde::de::MapAccess<'de>,
11250 {
11251 let mut table__ = None;
11252 let mut source__ = None;
11253 let mut job_type__ = None;
11254 while let Some(k) = map_.next_key()? {
11255 match k {
11256 GeneratedField::Table => {
11257 if table__.is_some() {
11258 return Err(serde::de::Error::duplicate_field("table"));
11259 }
11260 table__ = map_.next_value()?;
11261 }
11262 GeneratedField::Source => {
11263 if source__.is_some() {
11264 return Err(serde::de::Error::duplicate_field("source"));
11265 }
11266 source__ = map_.next_value()?;
11267 }
11268 GeneratedField::JobType => {
11269 if job_type__.is_some() {
11270 return Err(serde::de::Error::duplicate_field("jobType"));
11271 }
11272 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11273 }
11274 }
11275 }
11276 Ok(replace_job_plan::ReplaceTable {
11277 table: table__,
11278 source: source__,
11279 job_type: job_type__.unwrap_or_default(),
11280 })
11281 }
11282 }
11283 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11284 }
11285}
11286impl serde::Serialize for ReplaceJobPlanRequest {
11287 #[allow(deprecated)]
11288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11289 where
11290 S: serde::Serializer,
11291 {
11292 use serde::ser::SerializeStruct;
11293 let mut len = 0;
11294 if self.plan.is_some() {
11295 len += 1;
11296 }
11297 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11298 if let Some(v) = self.plan.as_ref() {
11299 struct_ser.serialize_field("plan", v)?;
11300 }
11301 struct_ser.end()
11302 }
11303}
11304impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11305 #[allow(deprecated)]
11306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11307 where
11308 D: serde::Deserializer<'de>,
11309 {
11310 const FIELDS: &[&str] = &[
11311 "plan",
11312 ];
11313
11314 #[allow(clippy::enum_variant_names)]
11315 enum GeneratedField {
11316 Plan,
11317 }
11318 impl<'de> serde::Deserialize<'de> for GeneratedField {
11319 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11320 where
11321 D: serde::Deserializer<'de>,
11322 {
11323 struct GeneratedVisitor;
11324
11325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11326 type Value = GeneratedField;
11327
11328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11329 write!(formatter, "expected one of: {:?}", &FIELDS)
11330 }
11331
11332 #[allow(unused_variables)]
11333 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11334 where
11335 E: serde::de::Error,
11336 {
11337 match value {
11338 "plan" => Ok(GeneratedField::Plan),
11339 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11340 }
11341 }
11342 }
11343 deserializer.deserialize_identifier(GeneratedVisitor)
11344 }
11345 }
11346 struct GeneratedVisitor;
11347 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11348 type Value = ReplaceJobPlanRequest;
11349
11350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11351 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11352 }
11353
11354 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11355 where
11356 V: serde::de::MapAccess<'de>,
11357 {
11358 let mut plan__ = None;
11359 while let Some(k) = map_.next_key()? {
11360 match k {
11361 GeneratedField::Plan => {
11362 if plan__.is_some() {
11363 return Err(serde::de::Error::duplicate_field("plan"));
11364 }
11365 plan__ = map_.next_value()?;
11366 }
11367 }
11368 }
11369 Ok(ReplaceJobPlanRequest {
11370 plan: plan__,
11371 })
11372 }
11373 }
11374 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11375 }
11376}
11377impl serde::Serialize for ReplaceJobPlanResponse {
11378 #[allow(deprecated)]
11379 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11380 where
11381 S: serde::Serializer,
11382 {
11383 use serde::ser::SerializeStruct;
11384 let mut len = 0;
11385 if self.status.is_some() {
11386 len += 1;
11387 }
11388 if self.version.is_some() {
11389 len += 1;
11390 }
11391 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11392 if let Some(v) = self.status.as_ref() {
11393 struct_ser.serialize_field("status", v)?;
11394 }
11395 if let Some(v) = self.version.as_ref() {
11396 struct_ser.serialize_field("version", v)?;
11397 }
11398 struct_ser.end()
11399 }
11400}
11401impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
11402 #[allow(deprecated)]
11403 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11404 where
11405 D: serde::Deserializer<'de>,
11406 {
11407 const FIELDS: &[&str] = &[
11408 "status",
11409 "version",
11410 ];
11411
11412 #[allow(clippy::enum_variant_names)]
11413 enum GeneratedField {
11414 Status,
11415 Version,
11416 }
11417 impl<'de> serde::Deserialize<'de> for GeneratedField {
11418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11419 where
11420 D: serde::Deserializer<'de>,
11421 {
11422 struct GeneratedVisitor;
11423
11424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11425 type Value = GeneratedField;
11426
11427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11428 write!(formatter, "expected one of: {:?}", &FIELDS)
11429 }
11430
11431 #[allow(unused_variables)]
11432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11433 where
11434 E: serde::de::Error,
11435 {
11436 match value {
11437 "status" => Ok(GeneratedField::Status),
11438 "version" => Ok(GeneratedField::Version),
11439 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11440 }
11441 }
11442 }
11443 deserializer.deserialize_identifier(GeneratedVisitor)
11444 }
11445 }
11446 struct GeneratedVisitor;
11447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11448 type Value = ReplaceJobPlanResponse;
11449
11450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11451 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
11452 }
11453
11454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
11455 where
11456 V: serde::de::MapAccess<'de>,
11457 {
11458 let mut status__ = None;
11459 let mut version__ = None;
11460 while let Some(k) = map_.next_key()? {
11461 match k {
11462 GeneratedField::Status => {
11463 if status__.is_some() {
11464 return Err(serde::de::Error::duplicate_field("status"));
11465 }
11466 status__ = map_.next_value()?;
11467 }
11468 GeneratedField::Version => {
11469 if version__.is_some() {
11470 return Err(serde::de::Error::duplicate_field("version"));
11471 }
11472 version__ = map_.next_value()?;
11473 }
11474 }
11475 }
11476 Ok(ReplaceJobPlanResponse {
11477 status: status__,
11478 version: version__,
11479 })
11480 }
11481 }
11482 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
11483 }
11484}
11485impl serde::Serialize for RisectlListStateTablesRequest {
11486 #[allow(deprecated)]
11487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11488 where
11489 S: serde::Serializer,
11490 {
11491 use serde::ser::SerializeStruct;
11492 let len = 0;
11493 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
11494 struct_ser.end()
11495 }
11496}
11497impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
11498 #[allow(deprecated)]
11499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11500 where
11501 D: serde::Deserializer<'de>,
11502 {
11503 const FIELDS: &[&str] = &[
11504 ];
11505
11506 #[allow(clippy::enum_variant_names)]
11507 enum GeneratedField {
11508 }
11509 impl<'de> serde::Deserialize<'de> for GeneratedField {
11510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11511 where
11512 D: serde::Deserializer<'de>,
11513 {
11514 struct GeneratedVisitor;
11515
11516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11517 type Value = GeneratedField;
11518
11519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11520 write!(formatter, "expected one of: {:?}", &FIELDS)
11521 }
11522
11523 #[allow(unused_variables)]
11524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11525 where
11526 E: serde::de::Error,
11527 {
11528 Err(serde::de::Error::unknown_field(value, FIELDS))
11529 }
11530 }
11531 deserializer.deserialize_identifier(GeneratedVisitor)
11532 }
11533 }
11534 struct GeneratedVisitor;
11535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11536 type Value = RisectlListStateTablesRequest;
11537
11538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11539 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
11540 }
11541
11542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
11543 where
11544 V: serde::de::MapAccess<'de>,
11545 {
11546 while map_.next_key::<GeneratedField>()?.is_some() {
11547 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11548 }
11549 Ok(RisectlListStateTablesRequest {
11550 })
11551 }
11552 }
11553 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
11554 }
11555}
11556impl serde::Serialize for RisectlListStateTablesResponse {
11557 #[allow(deprecated)]
11558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11559 where
11560 S: serde::Serializer,
11561 {
11562 use serde::ser::SerializeStruct;
11563 let mut len = 0;
11564 if !self.tables.is_empty() {
11565 len += 1;
11566 }
11567 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
11568 if !self.tables.is_empty() {
11569 struct_ser.serialize_field("tables", &self.tables)?;
11570 }
11571 struct_ser.end()
11572 }
11573}
11574impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
11575 #[allow(deprecated)]
11576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11577 where
11578 D: serde::Deserializer<'de>,
11579 {
11580 const FIELDS: &[&str] = &[
11581 "tables",
11582 ];
11583
11584 #[allow(clippy::enum_variant_names)]
11585 enum GeneratedField {
11586 Tables,
11587 }
11588 impl<'de> serde::Deserialize<'de> for GeneratedField {
11589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11590 where
11591 D: serde::Deserializer<'de>,
11592 {
11593 struct GeneratedVisitor;
11594
11595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11596 type Value = GeneratedField;
11597
11598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11599 write!(formatter, "expected one of: {:?}", &FIELDS)
11600 }
11601
11602 #[allow(unused_variables)]
11603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11604 where
11605 E: serde::de::Error,
11606 {
11607 match value {
11608 "tables" => Ok(GeneratedField::Tables),
11609 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11610 }
11611 }
11612 }
11613 deserializer.deserialize_identifier(GeneratedVisitor)
11614 }
11615 }
11616 struct GeneratedVisitor;
11617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11618 type Value = RisectlListStateTablesResponse;
11619
11620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11621 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
11622 }
11623
11624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
11625 where
11626 V: serde::de::MapAccess<'de>,
11627 {
11628 let mut tables__ = None;
11629 while let Some(k) = map_.next_key()? {
11630 match k {
11631 GeneratedField::Tables => {
11632 if tables__.is_some() {
11633 return Err(serde::de::Error::duplicate_field("tables"));
11634 }
11635 tables__ = Some(map_.next_value()?);
11636 }
11637 }
11638 }
11639 Ok(RisectlListStateTablesResponse {
11640 tables: tables__.unwrap_or_default(),
11641 })
11642 }
11643 }
11644 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
11645 }
11646}
11647impl serde::Serialize for SchemaChangeEnvelope {
11648 #[allow(deprecated)]
11649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11650 where
11651 S: serde::Serializer,
11652 {
11653 use serde::ser::SerializeStruct;
11654 let mut len = 0;
11655 if !self.table_changes.is_empty() {
11656 len += 1;
11657 }
11658 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
11659 if !self.table_changes.is_empty() {
11660 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
11661 }
11662 struct_ser.end()
11663 }
11664}
11665impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
11666 #[allow(deprecated)]
11667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11668 where
11669 D: serde::Deserializer<'de>,
11670 {
11671 const FIELDS: &[&str] = &[
11672 "table_changes",
11673 "tableChanges",
11674 ];
11675
11676 #[allow(clippy::enum_variant_names)]
11677 enum GeneratedField {
11678 TableChanges,
11679 }
11680 impl<'de> serde::Deserialize<'de> for GeneratedField {
11681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11682 where
11683 D: serde::Deserializer<'de>,
11684 {
11685 struct GeneratedVisitor;
11686
11687 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11688 type Value = GeneratedField;
11689
11690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11691 write!(formatter, "expected one of: {:?}", &FIELDS)
11692 }
11693
11694 #[allow(unused_variables)]
11695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11696 where
11697 E: serde::de::Error,
11698 {
11699 match value {
11700 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
11701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11702 }
11703 }
11704 }
11705 deserializer.deserialize_identifier(GeneratedVisitor)
11706 }
11707 }
11708 struct GeneratedVisitor;
11709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11710 type Value = SchemaChangeEnvelope;
11711
11712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11713 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
11714 }
11715
11716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
11717 where
11718 V: serde::de::MapAccess<'de>,
11719 {
11720 let mut table_changes__ = None;
11721 while let Some(k) = map_.next_key()? {
11722 match k {
11723 GeneratedField::TableChanges => {
11724 if table_changes__.is_some() {
11725 return Err(serde::de::Error::duplicate_field("tableChanges"));
11726 }
11727 table_changes__ = Some(map_.next_value()?);
11728 }
11729 }
11730 }
11731 Ok(SchemaChangeEnvelope {
11732 table_changes: table_changes__.unwrap_or_default(),
11733 })
11734 }
11735 }
11736 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
11737 }
11738}
11739impl serde::Serialize for TableJobType {
11740 #[allow(deprecated)]
11741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11742 where
11743 S: serde::Serializer,
11744 {
11745 let variant = match self {
11746 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
11747 Self::General => "TABLE_JOB_TYPE_GENERAL",
11748 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
11749 };
11750 serializer.serialize_str(variant)
11751 }
11752}
11753impl<'de> serde::Deserialize<'de> for TableJobType {
11754 #[allow(deprecated)]
11755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11756 where
11757 D: serde::Deserializer<'de>,
11758 {
11759 const FIELDS: &[&str] = &[
11760 "TABLE_JOB_TYPE_UNSPECIFIED",
11761 "TABLE_JOB_TYPE_GENERAL",
11762 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
11763 ];
11764
11765 struct GeneratedVisitor;
11766
11767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11768 type Value = TableJobType;
11769
11770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11771 write!(formatter, "expected one of: {:?}", &FIELDS)
11772 }
11773
11774 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11775 where
11776 E: serde::de::Error,
11777 {
11778 i32::try_from(v)
11779 .ok()
11780 .and_then(|x| x.try_into().ok())
11781 .ok_or_else(|| {
11782 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11783 })
11784 }
11785
11786 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11787 where
11788 E: serde::de::Error,
11789 {
11790 i32::try_from(v)
11791 .ok()
11792 .and_then(|x| x.try_into().ok())
11793 .ok_or_else(|| {
11794 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11795 })
11796 }
11797
11798 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11799 where
11800 E: serde::de::Error,
11801 {
11802 match value {
11803 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
11804 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
11805 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
11806 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11807 }
11808 }
11809 }
11810 deserializer.deserialize_any(GeneratedVisitor)
11811 }
11812}
11813impl serde::Serialize for TableSchemaChange {
11814 #[allow(deprecated)]
11815 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11816 where
11817 S: serde::Serializer,
11818 {
11819 use serde::ser::SerializeStruct;
11820 let mut len = 0;
11821 if self.change_type != 0 {
11822 len += 1;
11823 }
11824 if !self.cdc_table_id.is_empty() {
11825 len += 1;
11826 }
11827 if !self.columns.is_empty() {
11828 len += 1;
11829 }
11830 if !self.upstream_ddl.is_empty() {
11831 len += 1;
11832 }
11833 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
11834 if self.change_type != 0 {
11835 let v = table_schema_change::TableChangeType::try_from(self.change_type)
11836 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
11837 struct_ser.serialize_field("changeType", &v)?;
11838 }
11839 if !self.cdc_table_id.is_empty() {
11840 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
11841 }
11842 if !self.columns.is_empty() {
11843 struct_ser.serialize_field("columns", &self.columns)?;
11844 }
11845 if !self.upstream_ddl.is_empty() {
11846 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
11847 }
11848 struct_ser.end()
11849 }
11850}
11851impl<'de> serde::Deserialize<'de> for TableSchemaChange {
11852 #[allow(deprecated)]
11853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11854 where
11855 D: serde::Deserializer<'de>,
11856 {
11857 const FIELDS: &[&str] = &[
11858 "change_type",
11859 "changeType",
11860 "cdc_table_id",
11861 "cdcTableId",
11862 "columns",
11863 "upstream_ddl",
11864 "upstreamDdl",
11865 ];
11866
11867 #[allow(clippy::enum_variant_names)]
11868 enum GeneratedField {
11869 ChangeType,
11870 CdcTableId,
11871 Columns,
11872 UpstreamDdl,
11873 }
11874 impl<'de> serde::Deserialize<'de> for GeneratedField {
11875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11876 where
11877 D: serde::Deserializer<'de>,
11878 {
11879 struct GeneratedVisitor;
11880
11881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11882 type Value = GeneratedField;
11883
11884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11885 write!(formatter, "expected one of: {:?}", &FIELDS)
11886 }
11887
11888 #[allow(unused_variables)]
11889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11890 where
11891 E: serde::de::Error,
11892 {
11893 match value {
11894 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
11895 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
11896 "columns" => Ok(GeneratedField::Columns),
11897 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
11898 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11899 }
11900 }
11901 }
11902 deserializer.deserialize_identifier(GeneratedVisitor)
11903 }
11904 }
11905 struct GeneratedVisitor;
11906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11907 type Value = TableSchemaChange;
11908
11909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11910 formatter.write_str("struct ddl_service.TableSchemaChange")
11911 }
11912
11913 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
11914 where
11915 V: serde::de::MapAccess<'de>,
11916 {
11917 let mut change_type__ = None;
11918 let mut cdc_table_id__ = None;
11919 let mut columns__ = None;
11920 let mut upstream_ddl__ = None;
11921 while let Some(k) = map_.next_key()? {
11922 match k {
11923 GeneratedField::ChangeType => {
11924 if change_type__.is_some() {
11925 return Err(serde::de::Error::duplicate_field("changeType"));
11926 }
11927 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
11928 }
11929 GeneratedField::CdcTableId => {
11930 if cdc_table_id__.is_some() {
11931 return Err(serde::de::Error::duplicate_field("cdcTableId"));
11932 }
11933 cdc_table_id__ = Some(map_.next_value()?);
11934 }
11935 GeneratedField::Columns => {
11936 if columns__.is_some() {
11937 return Err(serde::de::Error::duplicate_field("columns"));
11938 }
11939 columns__ = Some(map_.next_value()?);
11940 }
11941 GeneratedField::UpstreamDdl => {
11942 if upstream_ddl__.is_some() {
11943 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
11944 }
11945 upstream_ddl__ = Some(map_.next_value()?);
11946 }
11947 }
11948 }
11949 Ok(TableSchemaChange {
11950 change_type: change_type__.unwrap_or_default(),
11951 cdc_table_id: cdc_table_id__.unwrap_or_default(),
11952 columns: columns__.unwrap_or_default(),
11953 upstream_ddl: upstream_ddl__.unwrap_or_default(),
11954 })
11955 }
11956 }
11957 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
11958 }
11959}
11960impl serde::Serialize for table_schema_change::TableChangeType {
11961 #[allow(deprecated)]
11962 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11963 where
11964 S: serde::Serializer,
11965 {
11966 let variant = match self {
11967 Self::Unspecified => "UNSPECIFIED",
11968 Self::Alter => "ALTER",
11969 Self::Create => "CREATE",
11970 Self::Drop => "DROP",
11971 };
11972 serializer.serialize_str(variant)
11973 }
11974}
11975impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
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 "UNSPECIFIED",
11983 "ALTER",
11984 "CREATE",
11985 "DROP",
11986 ];
11987
11988 struct GeneratedVisitor;
11989
11990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11991 type Value = table_schema_change::TableChangeType;
11992
11993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11994 write!(formatter, "expected one of: {:?}", &FIELDS)
11995 }
11996
11997 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11998 where
11999 E: serde::de::Error,
12000 {
12001 i32::try_from(v)
12002 .ok()
12003 .and_then(|x| x.try_into().ok())
12004 .ok_or_else(|| {
12005 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12006 })
12007 }
12008
12009 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12010 where
12011 E: serde::de::Error,
12012 {
12013 i32::try_from(v)
12014 .ok()
12015 .and_then(|x| x.try_into().ok())
12016 .ok_or_else(|| {
12017 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12018 })
12019 }
12020
12021 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12022 where
12023 E: serde::de::Error,
12024 {
12025 match value {
12026 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
12027 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
12028 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
12029 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
12030 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12031 }
12032 }
12033 }
12034 deserializer.deserialize_any(GeneratedVisitor)
12035 }
12036}
12037impl serde::Serialize for WaitRequest {
12038 #[allow(deprecated)]
12039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12040 where
12041 S: serde::Serializer,
12042 {
12043 use serde::ser::SerializeStruct;
12044 let len = 0;
12045 let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
12046 struct_ser.end()
12047 }
12048}
12049impl<'de> serde::Deserialize<'de> for WaitRequest {
12050 #[allow(deprecated)]
12051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12052 where
12053 D: serde::Deserializer<'de>,
12054 {
12055 const FIELDS: &[&str] = &[
12056 ];
12057
12058 #[allow(clippy::enum_variant_names)]
12059 enum GeneratedField {
12060 }
12061 impl<'de> serde::Deserialize<'de> for GeneratedField {
12062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12063 where
12064 D: serde::Deserializer<'de>,
12065 {
12066 struct GeneratedVisitor;
12067
12068 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12069 type Value = GeneratedField;
12070
12071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12072 write!(formatter, "expected one of: {:?}", &FIELDS)
12073 }
12074
12075 #[allow(unused_variables)]
12076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12077 where
12078 E: serde::de::Error,
12079 {
12080 Err(serde::de::Error::unknown_field(value, FIELDS))
12081 }
12082 }
12083 deserializer.deserialize_identifier(GeneratedVisitor)
12084 }
12085 }
12086 struct GeneratedVisitor;
12087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12088 type Value = WaitRequest;
12089
12090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12091 formatter.write_str("struct ddl_service.WaitRequest")
12092 }
12093
12094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
12095 where
12096 V: serde::de::MapAccess<'de>,
12097 {
12098 while map_.next_key::<GeneratedField>()?.is_some() {
12099 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12100 }
12101 Ok(WaitRequest {
12102 })
12103 }
12104 }
12105 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
12106 }
12107}
12108impl serde::Serialize for WaitResponse {
12109 #[allow(deprecated)]
12110 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12111 where
12112 S: serde::Serializer,
12113 {
12114 use serde::ser::SerializeStruct;
12115 let len = 0;
12116 let struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
12117 struct_ser.end()
12118 }
12119}
12120impl<'de> serde::Deserialize<'de> for WaitResponse {
12121 #[allow(deprecated)]
12122 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12123 where
12124 D: serde::Deserializer<'de>,
12125 {
12126 const FIELDS: &[&str] = &[
12127 ];
12128
12129 #[allow(clippy::enum_variant_names)]
12130 enum GeneratedField {
12131 }
12132 impl<'de> serde::Deserialize<'de> for GeneratedField {
12133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12134 where
12135 D: serde::Deserializer<'de>,
12136 {
12137 struct GeneratedVisitor;
12138
12139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12140 type Value = GeneratedField;
12141
12142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12143 write!(formatter, "expected one of: {:?}", &FIELDS)
12144 }
12145
12146 #[allow(unused_variables)]
12147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12148 where
12149 E: serde::de::Error,
12150 {
12151 Err(serde::de::Error::unknown_field(value, FIELDS))
12152 }
12153 }
12154 deserializer.deserialize_identifier(GeneratedVisitor)
12155 }
12156 }
12157 struct GeneratedVisitor;
12158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12159 type Value = WaitResponse;
12160
12161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12162 formatter.write_str("struct ddl_service.WaitResponse")
12163 }
12164
12165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
12166 where
12167 V: serde::de::MapAccess<'de>,
12168 {
12169 while map_.next_key::<GeneratedField>()?.is_some() {
12170 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12171 }
12172 Ok(WaitResponse {
12173 })
12174 }
12175 }
12176 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
12177 }
12178}
12179impl serde::Serialize for WaitVersion {
12180 #[allow(deprecated)]
12181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12182 where
12183 S: serde::Serializer,
12184 {
12185 use serde::ser::SerializeStruct;
12186 let mut len = 0;
12187 if self.catalog_version != 0 {
12188 len += 1;
12189 }
12190 if self.hummock_version_id != 0 {
12191 len += 1;
12192 }
12193 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
12194 if self.catalog_version != 0 {
12195 #[allow(clippy::needless_borrow)]
12196 #[allow(clippy::needless_borrows_for_generic_args)]
12197 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12198 }
12199 if self.hummock_version_id != 0 {
12200 #[allow(clippy::needless_borrow)]
12201 #[allow(clippy::needless_borrows_for_generic_args)]
12202 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
12203 }
12204 struct_ser.end()
12205 }
12206}
12207impl<'de> serde::Deserialize<'de> for WaitVersion {
12208 #[allow(deprecated)]
12209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12210 where
12211 D: serde::Deserializer<'de>,
12212 {
12213 const FIELDS: &[&str] = &[
12214 "catalog_version",
12215 "catalogVersion",
12216 "hummock_version_id",
12217 "hummockVersionId",
12218 ];
12219
12220 #[allow(clippy::enum_variant_names)]
12221 enum GeneratedField {
12222 CatalogVersion,
12223 HummockVersionId,
12224 }
12225 impl<'de> serde::Deserialize<'de> for GeneratedField {
12226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12227 where
12228 D: serde::Deserializer<'de>,
12229 {
12230 struct GeneratedVisitor;
12231
12232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12233 type Value = GeneratedField;
12234
12235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12236 write!(formatter, "expected one of: {:?}", &FIELDS)
12237 }
12238
12239 #[allow(unused_variables)]
12240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12241 where
12242 E: serde::de::Error,
12243 {
12244 match value {
12245 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12246 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
12247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12248 }
12249 }
12250 }
12251 deserializer.deserialize_identifier(GeneratedVisitor)
12252 }
12253 }
12254 struct GeneratedVisitor;
12255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12256 type Value = WaitVersion;
12257
12258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12259 formatter.write_str("struct ddl_service.WaitVersion")
12260 }
12261
12262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
12263 where
12264 V: serde::de::MapAccess<'de>,
12265 {
12266 let mut catalog_version__ = None;
12267 let mut hummock_version_id__ = None;
12268 while let Some(k) = map_.next_key()? {
12269 match k {
12270 GeneratedField::CatalogVersion => {
12271 if catalog_version__.is_some() {
12272 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12273 }
12274 catalog_version__ =
12275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12276 ;
12277 }
12278 GeneratedField::HummockVersionId => {
12279 if hummock_version_id__.is_some() {
12280 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
12281 }
12282 hummock_version_id__ =
12283 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12284 ;
12285 }
12286 }
12287 }
12288 Ok(WaitVersion {
12289 catalog_version: catalog_version__.unwrap_or_default(),
12290 hummock_version_id: hummock_version_id__.unwrap_or_default(),
12291 })
12292 }
12293 }
12294 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
12295 }
12296}