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