1use crate::ddl_service::*;
2impl serde::Serialize for AlterCdcTableBackfillParallelismRequest {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if self.table_id != 0 {
11 len += 1;
12 }
13 if self.parallelism.is_some() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", len)?;
17 if self.table_id != 0 {
18 struct_ser.serialize_field("tableId", &self.table_id)?;
19 }
20 if let Some(v) = self.parallelism.as_ref() {
21 struct_ser.serialize_field("parallelism", v)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismRequest {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "table_id",
34 "tableId",
35 "parallelism",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 TableId,
41 Parallelism,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "tableId" | "table_id" => Ok(GeneratedField::TableId),
64 "parallelism" => Ok(GeneratedField::Parallelism),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = AlterCdcTableBackfillParallelismRequest;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismRequest")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismRequest, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut table_id__ = None;
85 let mut parallelism__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::TableId => {
89 if table_id__.is_some() {
90 return Err(serde::de::Error::duplicate_field("tableId"));
91 }
92 table_id__ =
93 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
94 ;
95 }
96 GeneratedField::Parallelism => {
97 if parallelism__.is_some() {
98 return Err(serde::de::Error::duplicate_field("parallelism"));
99 }
100 parallelism__ = map_.next_value()?;
101 }
102 }
103 }
104 Ok(AlterCdcTableBackfillParallelismRequest {
105 table_id: table_id__.unwrap_or_default(),
106 parallelism: parallelism__,
107 })
108 }
109 }
110 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismRequest", FIELDS, GeneratedVisitor)
111 }
112}
113impl serde::Serialize for AlterCdcTableBackfillParallelismResponse {
114 #[allow(deprecated)]
115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116 where
117 S: serde::Serializer,
118 {
119 use serde::ser::SerializeStruct;
120 let len = 0;
121 let struct_ser = serializer.serialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", len)?;
122 struct_ser.end()
123 }
124}
125impl<'de> serde::Deserialize<'de> for AlterCdcTableBackfillParallelismResponse {
126 #[allow(deprecated)]
127 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
128 where
129 D: serde::Deserializer<'de>,
130 {
131 const FIELDS: &[&str] = &[
132 ];
133
134 #[allow(clippy::enum_variant_names)]
135 enum GeneratedField {
136 }
137 impl<'de> serde::Deserialize<'de> for GeneratedField {
138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
139 where
140 D: serde::Deserializer<'de>,
141 {
142 struct GeneratedVisitor;
143
144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
145 type Value = GeneratedField;
146
147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
148 write!(formatter, "expected one of: {:?}", &FIELDS)
149 }
150
151 #[allow(unused_variables)]
152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
153 where
154 E: serde::de::Error,
155 {
156 Err(serde::de::Error::unknown_field(value, FIELDS))
157 }
158 }
159 deserializer.deserialize_identifier(GeneratedVisitor)
160 }
161 }
162 struct GeneratedVisitor;
163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
164 type Value = AlterCdcTableBackfillParallelismResponse;
165
166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167 formatter.write_str("struct ddl_service.AlterCdcTableBackfillParallelismResponse")
168 }
169
170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterCdcTableBackfillParallelismResponse, V::Error>
171 where
172 V: serde::de::MapAccess<'de>,
173 {
174 while map_.next_key::<GeneratedField>()?.is_some() {
175 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
176 }
177 Ok(AlterCdcTableBackfillParallelismResponse {
178 })
179 }
180 }
181 deserializer.deserialize_struct("ddl_service.AlterCdcTableBackfillParallelismResponse", FIELDS, GeneratedVisitor)
182 }
183}
184impl serde::Serialize for AlterDatabaseParamRequest {
185 #[allow(deprecated)]
186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
187 where
188 S: serde::Serializer,
189 {
190 use serde::ser::SerializeStruct;
191 let mut len = 0;
192 if self.database_id != 0 {
193 len += 1;
194 }
195 if self.param.is_some() {
196 len += 1;
197 }
198 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamRequest", len)?;
199 if self.database_id != 0 {
200 struct_ser.serialize_field("databaseId", &self.database_id)?;
201 }
202 if let Some(v) = self.param.as_ref() {
203 match v {
204 alter_database_param_request::Param::BarrierIntervalMs(v) => {
205 struct_ser.serialize_field("barrierIntervalMs", v)?;
206 }
207 alter_database_param_request::Param::CheckpointFrequency(v) => {
208 struct_ser.serialize_field("checkpointFrequency", v)?;
209 }
210 }
211 }
212 struct_ser.end()
213 }
214}
215impl<'de> serde::Deserialize<'de> for AlterDatabaseParamRequest {
216 #[allow(deprecated)]
217 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
218 where
219 D: serde::Deserializer<'de>,
220 {
221 const FIELDS: &[&str] = &[
222 "database_id",
223 "databaseId",
224 "barrier_interval_ms",
225 "barrierIntervalMs",
226 "checkpoint_frequency",
227 "checkpointFrequency",
228 ];
229
230 #[allow(clippy::enum_variant_names)]
231 enum GeneratedField {
232 DatabaseId,
233 BarrierIntervalMs,
234 CheckpointFrequency,
235 }
236 impl<'de> serde::Deserialize<'de> for GeneratedField {
237 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
238 where
239 D: serde::Deserializer<'de>,
240 {
241 struct GeneratedVisitor;
242
243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
244 type Value = GeneratedField;
245
246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
247 write!(formatter, "expected one of: {:?}", &FIELDS)
248 }
249
250 #[allow(unused_variables)]
251 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
252 where
253 E: serde::de::Error,
254 {
255 match value {
256 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
257 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
258 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
259 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
260 }
261 }
262 }
263 deserializer.deserialize_identifier(GeneratedVisitor)
264 }
265 }
266 struct GeneratedVisitor;
267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
268 type Value = AlterDatabaseParamRequest;
269
270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
271 formatter.write_str("struct ddl_service.AlterDatabaseParamRequest")
272 }
273
274 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamRequest, V::Error>
275 where
276 V: serde::de::MapAccess<'de>,
277 {
278 let mut database_id__ = None;
279 let mut param__ = None;
280 while let Some(k) = map_.next_key()? {
281 match k {
282 GeneratedField::DatabaseId => {
283 if database_id__.is_some() {
284 return Err(serde::de::Error::duplicate_field("databaseId"));
285 }
286 database_id__ =
287 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
288 ;
289 }
290 GeneratedField::BarrierIntervalMs => {
291 if param__.is_some() {
292 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
293 }
294 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::BarrierIntervalMs)
295;
296 }
297 GeneratedField::CheckpointFrequency => {
298 if param__.is_some() {
299 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
300 }
301 param__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_database_param_request::Param::CheckpointFrequency)
302;
303 }
304 }
305 }
306 Ok(AlterDatabaseParamRequest {
307 database_id: database_id__.unwrap_or_default(),
308 param: param__,
309 })
310 }
311 }
312 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamRequest", FIELDS, GeneratedVisitor)
313 }
314}
315impl serde::Serialize for AlterDatabaseParamResponse {
316 #[allow(deprecated)]
317 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
318 where
319 S: serde::Serializer,
320 {
321 use serde::ser::SerializeStruct;
322 let mut len = 0;
323 if self.status.is_some() {
324 len += 1;
325 }
326 if self.version.is_some() {
327 len += 1;
328 }
329 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterDatabaseParamResponse", len)?;
330 if let Some(v) = self.status.as_ref() {
331 struct_ser.serialize_field("status", v)?;
332 }
333 if let Some(v) = self.version.as_ref() {
334 struct_ser.serialize_field("version", v)?;
335 }
336 struct_ser.end()
337 }
338}
339impl<'de> serde::Deserialize<'de> for AlterDatabaseParamResponse {
340 #[allow(deprecated)]
341 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
342 where
343 D: serde::Deserializer<'de>,
344 {
345 const FIELDS: &[&str] = &[
346 "status",
347 "version",
348 ];
349
350 #[allow(clippy::enum_variant_names)]
351 enum GeneratedField {
352 Status,
353 Version,
354 }
355 impl<'de> serde::Deserialize<'de> for GeneratedField {
356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
357 where
358 D: serde::Deserializer<'de>,
359 {
360 struct GeneratedVisitor;
361
362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
363 type Value = GeneratedField;
364
365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
366 write!(formatter, "expected one of: {:?}", &FIELDS)
367 }
368
369 #[allow(unused_variables)]
370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
371 where
372 E: serde::de::Error,
373 {
374 match value {
375 "status" => Ok(GeneratedField::Status),
376 "version" => Ok(GeneratedField::Version),
377 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
378 }
379 }
380 }
381 deserializer.deserialize_identifier(GeneratedVisitor)
382 }
383 }
384 struct GeneratedVisitor;
385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
386 type Value = AlterDatabaseParamResponse;
387
388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
389 formatter.write_str("struct ddl_service.AlterDatabaseParamResponse")
390 }
391
392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterDatabaseParamResponse, V::Error>
393 where
394 V: serde::de::MapAccess<'de>,
395 {
396 let mut status__ = None;
397 let mut version__ = None;
398 while let Some(k) = map_.next_key()? {
399 match k {
400 GeneratedField::Status => {
401 if status__.is_some() {
402 return Err(serde::de::Error::duplicate_field("status"));
403 }
404 status__ = map_.next_value()?;
405 }
406 GeneratedField::Version => {
407 if version__.is_some() {
408 return Err(serde::de::Error::duplicate_field("version"));
409 }
410 version__ = map_.next_value()?;
411 }
412 }
413 }
414 Ok(AlterDatabaseParamResponse {
415 status: status__,
416 version: version__,
417 })
418 }
419 }
420 deserializer.deserialize_struct("ddl_service.AlterDatabaseParamResponse", FIELDS, GeneratedVisitor)
421 }
422}
423impl serde::Serialize for AlterFragmentParallelismRequest {
424 #[allow(deprecated)]
425 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
426 where
427 S: serde::Serializer,
428 {
429 use serde::ser::SerializeStruct;
430 let mut len = 0;
431 if !self.fragment_ids.is_empty() {
432 len += 1;
433 }
434 if self.parallelism.is_some() {
435 len += 1;
436 }
437 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismRequest", len)?;
438 if !self.fragment_ids.is_empty() {
439 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
440 }
441 if let Some(v) = self.parallelism.as_ref() {
442 struct_ser.serialize_field("parallelism", v)?;
443 }
444 struct_ser.end()
445 }
446}
447impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismRequest {
448 #[allow(deprecated)]
449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
450 where
451 D: serde::Deserializer<'de>,
452 {
453 const FIELDS: &[&str] = &[
454 "fragment_ids",
455 "fragmentIds",
456 "parallelism",
457 ];
458
459 #[allow(clippy::enum_variant_names)]
460 enum GeneratedField {
461 FragmentIds,
462 Parallelism,
463 }
464 impl<'de> serde::Deserialize<'de> for GeneratedField {
465 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
466 where
467 D: serde::Deserializer<'de>,
468 {
469 struct GeneratedVisitor;
470
471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
472 type Value = GeneratedField;
473
474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
475 write!(formatter, "expected one of: {:?}", &FIELDS)
476 }
477
478 #[allow(unused_variables)]
479 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
480 where
481 E: serde::de::Error,
482 {
483 match value {
484 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
485 "parallelism" => Ok(GeneratedField::Parallelism),
486 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
487 }
488 }
489 }
490 deserializer.deserialize_identifier(GeneratedVisitor)
491 }
492 }
493 struct GeneratedVisitor;
494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
495 type Value = AlterFragmentParallelismRequest;
496
497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
498 formatter.write_str("struct ddl_service.AlterFragmentParallelismRequest")
499 }
500
501 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismRequest, V::Error>
502 where
503 V: serde::de::MapAccess<'de>,
504 {
505 let mut fragment_ids__ = None;
506 let mut parallelism__ = None;
507 while let Some(k) = map_.next_key()? {
508 match k {
509 GeneratedField::FragmentIds => {
510 if fragment_ids__.is_some() {
511 return Err(serde::de::Error::duplicate_field("fragmentIds"));
512 }
513 fragment_ids__ =
514 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
515 .into_iter().map(|x| x.0).collect())
516 ;
517 }
518 GeneratedField::Parallelism => {
519 if parallelism__.is_some() {
520 return Err(serde::de::Error::duplicate_field("parallelism"));
521 }
522 parallelism__ = map_.next_value()?;
523 }
524 }
525 }
526 Ok(AlterFragmentParallelismRequest {
527 fragment_ids: fragment_ids__.unwrap_or_default(),
528 parallelism: parallelism__,
529 })
530 }
531 }
532 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismRequest", FIELDS, GeneratedVisitor)
533 }
534}
535impl serde::Serialize for AlterFragmentParallelismResponse {
536 #[allow(deprecated)]
537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
538 where
539 S: serde::Serializer,
540 {
541 use serde::ser::SerializeStruct;
542 let len = 0;
543 let struct_ser = serializer.serialize_struct("ddl_service.AlterFragmentParallelismResponse", len)?;
544 struct_ser.end()
545 }
546}
547impl<'de> serde::Deserialize<'de> for AlterFragmentParallelismResponse {
548 #[allow(deprecated)]
549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
550 where
551 D: serde::Deserializer<'de>,
552 {
553 const FIELDS: &[&str] = &[
554 ];
555
556 #[allow(clippy::enum_variant_names)]
557 enum GeneratedField {
558 }
559 impl<'de> serde::Deserialize<'de> for GeneratedField {
560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
561 where
562 D: serde::Deserializer<'de>,
563 {
564 struct GeneratedVisitor;
565
566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
567 type Value = GeneratedField;
568
569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
570 write!(formatter, "expected one of: {:?}", &FIELDS)
571 }
572
573 #[allow(unused_variables)]
574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
575 where
576 E: serde::de::Error,
577 {
578 Err(serde::de::Error::unknown_field(value, FIELDS))
579 }
580 }
581 deserializer.deserialize_identifier(GeneratedVisitor)
582 }
583 }
584 struct GeneratedVisitor;
585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
586 type Value = AlterFragmentParallelismResponse;
587
588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
589 formatter.write_str("struct ddl_service.AlterFragmentParallelismResponse")
590 }
591
592 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterFragmentParallelismResponse, V::Error>
593 where
594 V: serde::de::MapAccess<'de>,
595 {
596 while map_.next_key::<GeneratedField>()?.is_some() {
597 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
598 }
599 Ok(AlterFragmentParallelismResponse {
600 })
601 }
602 }
603 deserializer.deserialize_struct("ddl_service.AlterFragmentParallelismResponse", FIELDS, GeneratedVisitor)
604 }
605}
606impl serde::Serialize for AlterNameRequest {
607 #[allow(deprecated)]
608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
609 where
610 S: serde::Serializer,
611 {
612 use serde::ser::SerializeStruct;
613 let mut len = 0;
614 if !self.new_name.is_empty() {
615 len += 1;
616 }
617 if self.object.is_some() {
618 len += 1;
619 }
620 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameRequest", len)?;
621 if !self.new_name.is_empty() {
622 struct_ser.serialize_field("newName", &self.new_name)?;
623 }
624 if let Some(v) = self.object.as_ref() {
625 match v {
626 alter_name_request::Object::TableId(v) => {
627 struct_ser.serialize_field("tableId", v)?;
628 }
629 alter_name_request::Object::ViewId(v) => {
630 struct_ser.serialize_field("viewId", v)?;
631 }
632 alter_name_request::Object::IndexId(v) => {
633 struct_ser.serialize_field("indexId", v)?;
634 }
635 alter_name_request::Object::SinkId(v) => {
636 struct_ser.serialize_field("sinkId", v)?;
637 }
638 alter_name_request::Object::SourceId(v) => {
639 struct_ser.serialize_field("sourceId", v)?;
640 }
641 alter_name_request::Object::SchemaId(v) => {
642 struct_ser.serialize_field("schemaId", v)?;
643 }
644 alter_name_request::Object::DatabaseId(v) => {
645 struct_ser.serialize_field("databaseId", v)?;
646 }
647 alter_name_request::Object::SubscriptionId(v) => {
648 struct_ser.serialize_field("subscriptionId", v)?;
649 }
650 }
651 }
652 struct_ser.end()
653 }
654}
655impl<'de> serde::Deserialize<'de> for AlterNameRequest {
656 #[allow(deprecated)]
657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
658 where
659 D: serde::Deserializer<'de>,
660 {
661 const FIELDS: &[&str] = &[
662 "new_name",
663 "newName",
664 "table_id",
665 "tableId",
666 "view_id",
667 "viewId",
668 "index_id",
669 "indexId",
670 "sink_id",
671 "sinkId",
672 "source_id",
673 "sourceId",
674 "schema_id",
675 "schemaId",
676 "database_id",
677 "databaseId",
678 "subscription_id",
679 "subscriptionId",
680 ];
681
682 #[allow(clippy::enum_variant_names)]
683 enum GeneratedField {
684 NewName,
685 TableId,
686 ViewId,
687 IndexId,
688 SinkId,
689 SourceId,
690 SchemaId,
691 DatabaseId,
692 SubscriptionId,
693 }
694 impl<'de> serde::Deserialize<'de> for GeneratedField {
695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
696 where
697 D: serde::Deserializer<'de>,
698 {
699 struct GeneratedVisitor;
700
701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
702 type Value = GeneratedField;
703
704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
705 write!(formatter, "expected one of: {:?}", &FIELDS)
706 }
707
708 #[allow(unused_variables)]
709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
710 where
711 E: serde::de::Error,
712 {
713 match value {
714 "newName" | "new_name" => Ok(GeneratedField::NewName),
715 "tableId" | "table_id" => Ok(GeneratedField::TableId),
716 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
717 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
718 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
719 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
720 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
721 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
722 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
723 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
724 }
725 }
726 }
727 deserializer.deserialize_identifier(GeneratedVisitor)
728 }
729 }
730 struct GeneratedVisitor;
731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
732 type Value = AlterNameRequest;
733
734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
735 formatter.write_str("struct ddl_service.AlterNameRequest")
736 }
737
738 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameRequest, V::Error>
739 where
740 V: serde::de::MapAccess<'de>,
741 {
742 let mut new_name__ = None;
743 let mut object__ = None;
744 while let Some(k) = map_.next_key()? {
745 match k {
746 GeneratedField::NewName => {
747 if new_name__.is_some() {
748 return Err(serde::de::Error::duplicate_field("newName"));
749 }
750 new_name__ = Some(map_.next_value()?);
751 }
752 GeneratedField::TableId => {
753 if object__.is_some() {
754 return Err(serde::de::Error::duplicate_field("tableId"));
755 }
756 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::TableId(x.0));
757 }
758 GeneratedField::ViewId => {
759 if object__.is_some() {
760 return Err(serde::de::Error::duplicate_field("viewId"));
761 }
762 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::ViewId(x.0));
763 }
764 GeneratedField::IndexId => {
765 if object__.is_some() {
766 return Err(serde::de::Error::duplicate_field("indexId"));
767 }
768 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::IndexId(x.0));
769 }
770 GeneratedField::SinkId => {
771 if object__.is_some() {
772 return Err(serde::de::Error::duplicate_field("sinkId"));
773 }
774 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SinkId(x.0));
775 }
776 GeneratedField::SourceId => {
777 if object__.is_some() {
778 return Err(serde::de::Error::duplicate_field("sourceId"));
779 }
780 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SourceId(x.0));
781 }
782 GeneratedField::SchemaId => {
783 if object__.is_some() {
784 return Err(serde::de::Error::duplicate_field("schemaId"));
785 }
786 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SchemaId(x.0));
787 }
788 GeneratedField::DatabaseId => {
789 if object__.is_some() {
790 return Err(serde::de::Error::duplicate_field("databaseId"));
791 }
792 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::DatabaseId(x.0));
793 }
794 GeneratedField::SubscriptionId => {
795 if object__.is_some() {
796 return Err(serde::de::Error::duplicate_field("subscriptionId"));
797 }
798 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_name_request::Object::SubscriptionId(x.0));
799 }
800 }
801 }
802 Ok(AlterNameRequest {
803 new_name: new_name__.unwrap_or_default(),
804 object: object__,
805 })
806 }
807 }
808 deserializer.deserialize_struct("ddl_service.AlterNameRequest", FIELDS, GeneratedVisitor)
809 }
810}
811impl serde::Serialize for AlterNameResponse {
812 #[allow(deprecated)]
813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
814 where
815 S: serde::Serializer,
816 {
817 use serde::ser::SerializeStruct;
818 let mut len = 0;
819 if self.status.is_some() {
820 len += 1;
821 }
822 if self.version.is_some() {
823 len += 1;
824 }
825 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterNameResponse", len)?;
826 if let Some(v) = self.status.as_ref() {
827 struct_ser.serialize_field("status", v)?;
828 }
829 if let Some(v) = self.version.as_ref() {
830 struct_ser.serialize_field("version", v)?;
831 }
832 struct_ser.end()
833 }
834}
835impl<'de> serde::Deserialize<'de> for AlterNameResponse {
836 #[allow(deprecated)]
837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
838 where
839 D: serde::Deserializer<'de>,
840 {
841 const FIELDS: &[&str] = &[
842 "status",
843 "version",
844 ];
845
846 #[allow(clippy::enum_variant_names)]
847 enum GeneratedField {
848 Status,
849 Version,
850 }
851 impl<'de> serde::Deserialize<'de> for GeneratedField {
852 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
853 where
854 D: serde::Deserializer<'de>,
855 {
856 struct GeneratedVisitor;
857
858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
859 type Value = GeneratedField;
860
861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
862 write!(formatter, "expected one of: {:?}", &FIELDS)
863 }
864
865 #[allow(unused_variables)]
866 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
867 where
868 E: serde::de::Error,
869 {
870 match value {
871 "status" => Ok(GeneratedField::Status),
872 "version" => Ok(GeneratedField::Version),
873 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
874 }
875 }
876 }
877 deserializer.deserialize_identifier(GeneratedVisitor)
878 }
879 }
880 struct GeneratedVisitor;
881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
882 type Value = AlterNameResponse;
883
884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
885 formatter.write_str("struct ddl_service.AlterNameResponse")
886 }
887
888 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterNameResponse, V::Error>
889 where
890 V: serde::de::MapAccess<'de>,
891 {
892 let mut status__ = None;
893 let mut version__ = None;
894 while let Some(k) = map_.next_key()? {
895 match k {
896 GeneratedField::Status => {
897 if status__.is_some() {
898 return Err(serde::de::Error::duplicate_field("status"));
899 }
900 status__ = map_.next_value()?;
901 }
902 GeneratedField::Version => {
903 if version__.is_some() {
904 return Err(serde::de::Error::duplicate_field("version"));
905 }
906 version__ = map_.next_value()?;
907 }
908 }
909 }
910 Ok(AlterNameResponse {
911 status: status__,
912 version: version__,
913 })
914 }
915 }
916 deserializer.deserialize_struct("ddl_service.AlterNameResponse", FIELDS, GeneratedVisitor)
917 }
918}
919impl serde::Serialize for AlterOwnerRequest {
920 #[allow(deprecated)]
921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
922 where
923 S: serde::Serializer,
924 {
925 use serde::ser::SerializeStruct;
926 let mut len = 0;
927 if self.owner_id != 0 {
928 len += 1;
929 }
930 if self.object.is_some() {
931 len += 1;
932 }
933 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerRequest", len)?;
934 if self.owner_id != 0 {
935 struct_ser.serialize_field("ownerId", &self.owner_id)?;
936 }
937 if let Some(v) = self.object.as_ref() {
938 match v {
939 alter_owner_request::Object::TableId(v) => {
940 struct_ser.serialize_field("tableId", v)?;
941 }
942 alter_owner_request::Object::ViewId(v) => {
943 struct_ser.serialize_field("viewId", v)?;
944 }
945 alter_owner_request::Object::SourceId(v) => {
946 struct_ser.serialize_field("sourceId", v)?;
947 }
948 alter_owner_request::Object::SinkId(v) => {
949 struct_ser.serialize_field("sinkId", v)?;
950 }
951 alter_owner_request::Object::SchemaId(v) => {
952 struct_ser.serialize_field("schemaId", v)?;
953 }
954 alter_owner_request::Object::DatabaseId(v) => {
955 struct_ser.serialize_field("databaseId", v)?;
956 }
957 alter_owner_request::Object::SubscriptionId(v) => {
958 struct_ser.serialize_field("subscriptionId", v)?;
959 }
960 alter_owner_request::Object::ConnectionId(v) => {
961 struct_ser.serialize_field("connectionId", v)?;
962 }
963 }
964 }
965 struct_ser.end()
966 }
967}
968impl<'de> serde::Deserialize<'de> for AlterOwnerRequest {
969 #[allow(deprecated)]
970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
971 where
972 D: serde::Deserializer<'de>,
973 {
974 const FIELDS: &[&str] = &[
975 "owner_id",
976 "ownerId",
977 "table_id",
978 "tableId",
979 "view_id",
980 "viewId",
981 "source_id",
982 "sourceId",
983 "sink_id",
984 "sinkId",
985 "schema_id",
986 "schemaId",
987 "database_id",
988 "databaseId",
989 "subscription_id",
990 "subscriptionId",
991 "connection_id",
992 "connectionId",
993 ];
994
995 #[allow(clippy::enum_variant_names)]
996 enum GeneratedField {
997 OwnerId,
998 TableId,
999 ViewId,
1000 SourceId,
1001 SinkId,
1002 SchemaId,
1003 DatabaseId,
1004 SubscriptionId,
1005 ConnectionId,
1006 }
1007 impl<'de> serde::Deserialize<'de> for GeneratedField {
1008 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1009 where
1010 D: serde::Deserializer<'de>,
1011 {
1012 struct GeneratedVisitor;
1013
1014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1015 type Value = GeneratedField;
1016
1017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1018 write!(formatter, "expected one of: {:?}", &FIELDS)
1019 }
1020
1021 #[allow(unused_variables)]
1022 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1023 where
1024 E: serde::de::Error,
1025 {
1026 match value {
1027 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1028 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1029 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
1030 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1031 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1032 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1033 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1034 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
1035 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
1036 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1037 }
1038 }
1039 }
1040 deserializer.deserialize_identifier(GeneratedVisitor)
1041 }
1042 }
1043 struct GeneratedVisitor;
1044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1045 type Value = AlterOwnerRequest;
1046
1047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1048 formatter.write_str("struct ddl_service.AlterOwnerRequest")
1049 }
1050
1051 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerRequest, V::Error>
1052 where
1053 V: serde::de::MapAccess<'de>,
1054 {
1055 let mut owner_id__ = None;
1056 let mut object__ = None;
1057 while let Some(k) = map_.next_key()? {
1058 match k {
1059 GeneratedField::OwnerId => {
1060 if owner_id__.is_some() {
1061 return Err(serde::de::Error::duplicate_field("ownerId"));
1062 }
1063 owner_id__ =
1064 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1065 ;
1066 }
1067 GeneratedField::TableId => {
1068 if object__.is_some() {
1069 return Err(serde::de::Error::duplicate_field("tableId"));
1070 }
1071 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::TableId(x.0));
1072 }
1073 GeneratedField::ViewId => {
1074 if object__.is_some() {
1075 return Err(serde::de::Error::duplicate_field("viewId"));
1076 }
1077 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ViewId(x.0));
1078 }
1079 GeneratedField::SourceId => {
1080 if object__.is_some() {
1081 return Err(serde::de::Error::duplicate_field("sourceId"));
1082 }
1083 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SourceId(x.0));
1084 }
1085 GeneratedField::SinkId => {
1086 if object__.is_some() {
1087 return Err(serde::de::Error::duplicate_field("sinkId"));
1088 }
1089 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SinkId(x.0));
1090 }
1091 GeneratedField::SchemaId => {
1092 if object__.is_some() {
1093 return Err(serde::de::Error::duplicate_field("schemaId"));
1094 }
1095 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SchemaId(x.0));
1096 }
1097 GeneratedField::DatabaseId => {
1098 if object__.is_some() {
1099 return Err(serde::de::Error::duplicate_field("databaseId"));
1100 }
1101 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::DatabaseId(x.0));
1102 }
1103 GeneratedField::SubscriptionId => {
1104 if object__.is_some() {
1105 return Err(serde::de::Error::duplicate_field("subscriptionId"));
1106 }
1107 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::SubscriptionId(x.0));
1108 }
1109 GeneratedField::ConnectionId => {
1110 if object__.is_some() {
1111 return Err(serde::de::Error::duplicate_field("connectionId"));
1112 }
1113 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_owner_request::Object::ConnectionId(x.0));
1114 }
1115 }
1116 }
1117 Ok(AlterOwnerRequest {
1118 owner_id: owner_id__.unwrap_or_default(),
1119 object: object__,
1120 })
1121 }
1122 }
1123 deserializer.deserialize_struct("ddl_service.AlterOwnerRequest", FIELDS, GeneratedVisitor)
1124 }
1125}
1126impl serde::Serialize for AlterOwnerResponse {
1127 #[allow(deprecated)]
1128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1129 where
1130 S: serde::Serializer,
1131 {
1132 use serde::ser::SerializeStruct;
1133 let mut len = 0;
1134 if self.status.is_some() {
1135 len += 1;
1136 }
1137 if self.version.is_some() {
1138 len += 1;
1139 }
1140 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterOwnerResponse", len)?;
1141 if let Some(v) = self.status.as_ref() {
1142 struct_ser.serialize_field("status", v)?;
1143 }
1144 if let Some(v) = self.version.as_ref() {
1145 struct_ser.serialize_field("version", v)?;
1146 }
1147 struct_ser.end()
1148 }
1149}
1150impl<'de> serde::Deserialize<'de> for AlterOwnerResponse {
1151 #[allow(deprecated)]
1152 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1153 where
1154 D: serde::Deserializer<'de>,
1155 {
1156 const FIELDS: &[&str] = &[
1157 "status",
1158 "version",
1159 ];
1160
1161 #[allow(clippy::enum_variant_names)]
1162 enum GeneratedField {
1163 Status,
1164 Version,
1165 }
1166 impl<'de> serde::Deserialize<'de> for GeneratedField {
1167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1168 where
1169 D: serde::Deserializer<'de>,
1170 {
1171 struct GeneratedVisitor;
1172
1173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1174 type Value = GeneratedField;
1175
1176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1177 write!(formatter, "expected one of: {:?}", &FIELDS)
1178 }
1179
1180 #[allow(unused_variables)]
1181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1182 where
1183 E: serde::de::Error,
1184 {
1185 match value {
1186 "status" => Ok(GeneratedField::Status),
1187 "version" => Ok(GeneratedField::Version),
1188 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1189 }
1190 }
1191 }
1192 deserializer.deserialize_identifier(GeneratedVisitor)
1193 }
1194 }
1195 struct GeneratedVisitor;
1196 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1197 type Value = AlterOwnerResponse;
1198
1199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1200 formatter.write_str("struct ddl_service.AlterOwnerResponse")
1201 }
1202
1203 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterOwnerResponse, V::Error>
1204 where
1205 V: serde::de::MapAccess<'de>,
1206 {
1207 let mut status__ = None;
1208 let mut version__ = None;
1209 while let Some(k) = map_.next_key()? {
1210 match k {
1211 GeneratedField::Status => {
1212 if status__.is_some() {
1213 return Err(serde::de::Error::duplicate_field("status"));
1214 }
1215 status__ = map_.next_value()?;
1216 }
1217 GeneratedField::Version => {
1218 if version__.is_some() {
1219 return Err(serde::de::Error::duplicate_field("version"));
1220 }
1221 version__ = map_.next_value()?;
1222 }
1223 }
1224 }
1225 Ok(AlterOwnerResponse {
1226 status: status__,
1227 version: version__,
1228 })
1229 }
1230 }
1231 deserializer.deserialize_struct("ddl_service.AlterOwnerResponse", FIELDS, GeneratedVisitor)
1232 }
1233}
1234impl serde::Serialize for AlterParallelismRequest {
1235 #[allow(deprecated)]
1236 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1237 where
1238 S: serde::Serializer,
1239 {
1240 use serde::ser::SerializeStruct;
1241 let mut len = 0;
1242 if self.table_id != 0 {
1243 len += 1;
1244 }
1245 if self.parallelism.is_some() {
1246 len += 1;
1247 }
1248 if self.deferred {
1249 len += 1;
1250 }
1251 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismRequest", len)?;
1252 if self.table_id != 0 {
1253 struct_ser.serialize_field("tableId", &self.table_id)?;
1254 }
1255 if let Some(v) = self.parallelism.as_ref() {
1256 struct_ser.serialize_field("parallelism", v)?;
1257 }
1258 if self.deferred {
1259 struct_ser.serialize_field("deferred", &self.deferred)?;
1260 }
1261 struct_ser.end()
1262 }
1263}
1264impl<'de> serde::Deserialize<'de> for AlterParallelismRequest {
1265 #[allow(deprecated)]
1266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1267 where
1268 D: serde::Deserializer<'de>,
1269 {
1270 const FIELDS: &[&str] = &[
1271 "table_id",
1272 "tableId",
1273 "parallelism",
1274 "deferred",
1275 ];
1276
1277 #[allow(clippy::enum_variant_names)]
1278 enum GeneratedField {
1279 TableId,
1280 Parallelism,
1281 Deferred,
1282 }
1283 impl<'de> serde::Deserialize<'de> for GeneratedField {
1284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1285 where
1286 D: serde::Deserializer<'de>,
1287 {
1288 struct GeneratedVisitor;
1289
1290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1291 type Value = GeneratedField;
1292
1293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1294 write!(formatter, "expected one of: {:?}", &FIELDS)
1295 }
1296
1297 #[allow(unused_variables)]
1298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1299 where
1300 E: serde::de::Error,
1301 {
1302 match value {
1303 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1304 "parallelism" => Ok(GeneratedField::Parallelism),
1305 "deferred" => Ok(GeneratedField::Deferred),
1306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1307 }
1308 }
1309 }
1310 deserializer.deserialize_identifier(GeneratedVisitor)
1311 }
1312 }
1313 struct GeneratedVisitor;
1314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1315 type Value = AlterParallelismRequest;
1316
1317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1318 formatter.write_str("struct ddl_service.AlterParallelismRequest")
1319 }
1320
1321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismRequest, V::Error>
1322 where
1323 V: serde::de::MapAccess<'de>,
1324 {
1325 let mut table_id__ = None;
1326 let mut parallelism__ = None;
1327 let mut deferred__ = None;
1328 while let Some(k) = map_.next_key()? {
1329 match k {
1330 GeneratedField::TableId => {
1331 if table_id__.is_some() {
1332 return Err(serde::de::Error::duplicate_field("tableId"));
1333 }
1334 table_id__ =
1335 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1336 ;
1337 }
1338 GeneratedField::Parallelism => {
1339 if parallelism__.is_some() {
1340 return Err(serde::de::Error::duplicate_field("parallelism"));
1341 }
1342 parallelism__ = map_.next_value()?;
1343 }
1344 GeneratedField::Deferred => {
1345 if deferred__.is_some() {
1346 return Err(serde::de::Error::duplicate_field("deferred"));
1347 }
1348 deferred__ = Some(map_.next_value()?);
1349 }
1350 }
1351 }
1352 Ok(AlterParallelismRequest {
1353 table_id: table_id__.unwrap_or_default(),
1354 parallelism: parallelism__,
1355 deferred: deferred__.unwrap_or_default(),
1356 })
1357 }
1358 }
1359 deserializer.deserialize_struct("ddl_service.AlterParallelismRequest", FIELDS, GeneratedVisitor)
1360 }
1361}
1362impl serde::Serialize for AlterParallelismResponse {
1363 #[allow(deprecated)]
1364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1365 where
1366 S: serde::Serializer,
1367 {
1368 use serde::ser::SerializeStruct;
1369 let len = 0;
1370 let struct_ser = serializer.serialize_struct("ddl_service.AlterParallelismResponse", len)?;
1371 struct_ser.end()
1372 }
1373}
1374impl<'de> serde::Deserialize<'de> for AlterParallelismResponse {
1375 #[allow(deprecated)]
1376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1377 where
1378 D: serde::Deserializer<'de>,
1379 {
1380 const FIELDS: &[&str] = &[
1381 ];
1382
1383 #[allow(clippy::enum_variant_names)]
1384 enum GeneratedField {
1385 }
1386 impl<'de> serde::Deserialize<'de> for GeneratedField {
1387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1388 where
1389 D: serde::Deserializer<'de>,
1390 {
1391 struct GeneratedVisitor;
1392
1393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1394 type Value = GeneratedField;
1395
1396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1397 write!(formatter, "expected one of: {:?}", &FIELDS)
1398 }
1399
1400 #[allow(unused_variables)]
1401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1402 where
1403 E: serde::de::Error,
1404 {
1405 Err(serde::de::Error::unknown_field(value, FIELDS))
1406 }
1407 }
1408 deserializer.deserialize_identifier(GeneratedVisitor)
1409 }
1410 }
1411 struct GeneratedVisitor;
1412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1413 type Value = AlterParallelismResponse;
1414
1415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1416 formatter.write_str("struct ddl_service.AlterParallelismResponse")
1417 }
1418
1419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterParallelismResponse, V::Error>
1420 where
1421 V: serde::de::MapAccess<'de>,
1422 {
1423 while map_.next_key::<GeneratedField>()?.is_some() {
1424 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1425 }
1426 Ok(AlterParallelismResponse {
1427 })
1428 }
1429 }
1430 deserializer.deserialize_struct("ddl_service.AlterParallelismResponse", FIELDS, GeneratedVisitor)
1431 }
1432}
1433impl serde::Serialize for AlterResourceGroupRequest {
1434 #[allow(deprecated)]
1435 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1436 where
1437 S: serde::Serializer,
1438 {
1439 use serde::ser::SerializeStruct;
1440 let mut len = 0;
1441 if self.table_id != 0 {
1442 len += 1;
1443 }
1444 if self.resource_group.is_some() {
1445 len += 1;
1446 }
1447 if self.deferred {
1448 len += 1;
1449 }
1450 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupRequest", len)?;
1451 if self.table_id != 0 {
1452 struct_ser.serialize_field("tableId", &self.table_id)?;
1453 }
1454 if let Some(v) = self.resource_group.as_ref() {
1455 struct_ser.serialize_field("resourceGroup", v)?;
1456 }
1457 if self.deferred {
1458 struct_ser.serialize_field("deferred", &self.deferred)?;
1459 }
1460 struct_ser.end()
1461 }
1462}
1463impl<'de> serde::Deserialize<'de> for AlterResourceGroupRequest {
1464 #[allow(deprecated)]
1465 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1466 where
1467 D: serde::Deserializer<'de>,
1468 {
1469 const FIELDS: &[&str] = &[
1470 "table_id",
1471 "tableId",
1472 "resource_group",
1473 "resourceGroup",
1474 "deferred",
1475 ];
1476
1477 #[allow(clippy::enum_variant_names)]
1478 enum GeneratedField {
1479 TableId,
1480 ResourceGroup,
1481 Deferred,
1482 }
1483 impl<'de> serde::Deserialize<'de> for GeneratedField {
1484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1485 where
1486 D: serde::Deserializer<'de>,
1487 {
1488 struct GeneratedVisitor;
1489
1490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1491 type Value = GeneratedField;
1492
1493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1494 write!(formatter, "expected one of: {:?}", &FIELDS)
1495 }
1496
1497 #[allow(unused_variables)]
1498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1499 where
1500 E: serde::de::Error,
1501 {
1502 match value {
1503 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1504 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1505 "deferred" => Ok(GeneratedField::Deferred),
1506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1507 }
1508 }
1509 }
1510 deserializer.deserialize_identifier(GeneratedVisitor)
1511 }
1512 }
1513 struct GeneratedVisitor;
1514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1515 type Value = AlterResourceGroupRequest;
1516
1517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1518 formatter.write_str("struct ddl_service.AlterResourceGroupRequest")
1519 }
1520
1521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupRequest, V::Error>
1522 where
1523 V: serde::de::MapAccess<'de>,
1524 {
1525 let mut table_id__ = None;
1526 let mut resource_group__ = None;
1527 let mut deferred__ = None;
1528 while let Some(k) = map_.next_key()? {
1529 match k {
1530 GeneratedField::TableId => {
1531 if table_id__.is_some() {
1532 return Err(serde::de::Error::duplicate_field("tableId"));
1533 }
1534 table_id__ =
1535 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1536 ;
1537 }
1538 GeneratedField::ResourceGroup => {
1539 if resource_group__.is_some() {
1540 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1541 }
1542 resource_group__ = map_.next_value()?;
1543 }
1544 GeneratedField::Deferred => {
1545 if deferred__.is_some() {
1546 return Err(serde::de::Error::duplicate_field("deferred"));
1547 }
1548 deferred__ = Some(map_.next_value()?);
1549 }
1550 }
1551 }
1552 Ok(AlterResourceGroupRequest {
1553 table_id: table_id__.unwrap_or_default(),
1554 resource_group: resource_group__,
1555 deferred: deferred__.unwrap_or_default(),
1556 })
1557 }
1558 }
1559 deserializer.deserialize_struct("ddl_service.AlterResourceGroupRequest", FIELDS, GeneratedVisitor)
1560 }
1561}
1562impl serde::Serialize for AlterResourceGroupResponse {
1563 #[allow(deprecated)]
1564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1565 where
1566 S: serde::Serializer,
1567 {
1568 use serde::ser::SerializeStruct;
1569 let len = 0;
1570 let struct_ser = serializer.serialize_struct("ddl_service.AlterResourceGroupResponse", len)?;
1571 struct_ser.end()
1572 }
1573}
1574impl<'de> serde::Deserialize<'de> for AlterResourceGroupResponse {
1575 #[allow(deprecated)]
1576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1577 where
1578 D: serde::Deserializer<'de>,
1579 {
1580 const FIELDS: &[&str] = &[
1581 ];
1582
1583 #[allow(clippy::enum_variant_names)]
1584 enum GeneratedField {
1585 }
1586 impl<'de> serde::Deserialize<'de> for GeneratedField {
1587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1588 where
1589 D: serde::Deserializer<'de>,
1590 {
1591 struct GeneratedVisitor;
1592
1593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1594 type Value = GeneratedField;
1595
1596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1597 write!(formatter, "expected one of: {:?}", &FIELDS)
1598 }
1599
1600 #[allow(unused_variables)]
1601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1602 where
1603 E: serde::de::Error,
1604 {
1605 Err(serde::de::Error::unknown_field(value, FIELDS))
1606 }
1607 }
1608 deserializer.deserialize_identifier(GeneratedVisitor)
1609 }
1610 }
1611 struct GeneratedVisitor;
1612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1613 type Value = AlterResourceGroupResponse;
1614
1615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1616 formatter.write_str("struct ddl_service.AlterResourceGroupResponse")
1617 }
1618
1619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterResourceGroupResponse, V::Error>
1620 where
1621 V: serde::de::MapAccess<'de>,
1622 {
1623 while map_.next_key::<GeneratedField>()?.is_some() {
1624 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1625 }
1626 Ok(AlterResourceGroupResponse {
1627 })
1628 }
1629 }
1630 deserializer.deserialize_struct("ddl_service.AlterResourceGroupResponse", FIELDS, GeneratedVisitor)
1631 }
1632}
1633impl serde::Serialize for AlterSecretRequest {
1634 #[allow(deprecated)]
1635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1636 where
1637 S: serde::Serializer,
1638 {
1639 use serde::ser::SerializeStruct;
1640 let mut len = 0;
1641 if self.secret_id != 0 {
1642 len += 1;
1643 }
1644 if !self.name.is_empty() {
1645 len += 1;
1646 }
1647 if !self.value.is_empty() {
1648 len += 1;
1649 }
1650 if self.database_id != 0 {
1651 len += 1;
1652 }
1653 if self.schema_id != 0 {
1654 len += 1;
1655 }
1656 if self.owner_id != 0 {
1657 len += 1;
1658 }
1659 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretRequest", len)?;
1660 if self.secret_id != 0 {
1661 struct_ser.serialize_field("secretId", &self.secret_id)?;
1662 }
1663 if !self.name.is_empty() {
1664 struct_ser.serialize_field("name", &self.name)?;
1665 }
1666 if !self.value.is_empty() {
1667 #[allow(clippy::needless_borrow)]
1668 #[allow(clippy::needless_borrows_for_generic_args)]
1669 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
1670 }
1671 if self.database_id != 0 {
1672 struct_ser.serialize_field("databaseId", &self.database_id)?;
1673 }
1674 if self.schema_id != 0 {
1675 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1676 }
1677 if self.owner_id != 0 {
1678 struct_ser.serialize_field("ownerId", &self.owner_id)?;
1679 }
1680 struct_ser.end()
1681 }
1682}
1683impl<'de> serde::Deserialize<'de> for AlterSecretRequest {
1684 #[allow(deprecated)]
1685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1686 where
1687 D: serde::Deserializer<'de>,
1688 {
1689 const FIELDS: &[&str] = &[
1690 "secret_id",
1691 "secretId",
1692 "name",
1693 "value",
1694 "database_id",
1695 "databaseId",
1696 "schema_id",
1697 "schemaId",
1698 "owner_id",
1699 "ownerId",
1700 ];
1701
1702 #[allow(clippy::enum_variant_names)]
1703 enum GeneratedField {
1704 SecretId,
1705 Name,
1706 Value,
1707 DatabaseId,
1708 SchemaId,
1709 OwnerId,
1710 }
1711 impl<'de> serde::Deserialize<'de> for GeneratedField {
1712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1713 where
1714 D: serde::Deserializer<'de>,
1715 {
1716 struct GeneratedVisitor;
1717
1718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1719 type Value = GeneratedField;
1720
1721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1722 write!(formatter, "expected one of: {:?}", &FIELDS)
1723 }
1724
1725 #[allow(unused_variables)]
1726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1727 where
1728 E: serde::de::Error,
1729 {
1730 match value {
1731 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
1732 "name" => Ok(GeneratedField::Name),
1733 "value" => Ok(GeneratedField::Value),
1734 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1735 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1736 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
1737 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1738 }
1739 }
1740 }
1741 deserializer.deserialize_identifier(GeneratedVisitor)
1742 }
1743 }
1744 struct GeneratedVisitor;
1745 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1746 type Value = AlterSecretRequest;
1747
1748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1749 formatter.write_str("struct ddl_service.AlterSecretRequest")
1750 }
1751
1752 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretRequest, V::Error>
1753 where
1754 V: serde::de::MapAccess<'de>,
1755 {
1756 let mut secret_id__ = None;
1757 let mut name__ = None;
1758 let mut value__ = None;
1759 let mut database_id__ = None;
1760 let mut schema_id__ = None;
1761 let mut owner_id__ = None;
1762 while let Some(k) = map_.next_key()? {
1763 match k {
1764 GeneratedField::SecretId => {
1765 if secret_id__.is_some() {
1766 return Err(serde::de::Error::duplicate_field("secretId"));
1767 }
1768 secret_id__ =
1769 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1770 ;
1771 }
1772 GeneratedField::Name => {
1773 if name__.is_some() {
1774 return Err(serde::de::Error::duplicate_field("name"));
1775 }
1776 name__ = Some(map_.next_value()?);
1777 }
1778 GeneratedField::Value => {
1779 if value__.is_some() {
1780 return Err(serde::de::Error::duplicate_field("value"));
1781 }
1782 value__ =
1783 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
1784 ;
1785 }
1786 GeneratedField::DatabaseId => {
1787 if database_id__.is_some() {
1788 return Err(serde::de::Error::duplicate_field("databaseId"));
1789 }
1790 database_id__ =
1791 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1792 ;
1793 }
1794 GeneratedField::SchemaId => {
1795 if schema_id__.is_some() {
1796 return Err(serde::de::Error::duplicate_field("schemaId"));
1797 }
1798 schema_id__ =
1799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1800 ;
1801 }
1802 GeneratedField::OwnerId => {
1803 if owner_id__.is_some() {
1804 return Err(serde::de::Error::duplicate_field("ownerId"));
1805 }
1806 owner_id__ =
1807 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1808 ;
1809 }
1810 }
1811 }
1812 Ok(AlterSecretRequest {
1813 secret_id: secret_id__.unwrap_or_default(),
1814 name: name__.unwrap_or_default(),
1815 value: value__.unwrap_or_default(),
1816 database_id: database_id__.unwrap_or_default(),
1817 schema_id: schema_id__.unwrap_or_default(),
1818 owner_id: owner_id__.unwrap_or_default(),
1819 })
1820 }
1821 }
1822 deserializer.deserialize_struct("ddl_service.AlterSecretRequest", FIELDS, GeneratedVisitor)
1823 }
1824}
1825impl serde::Serialize for AlterSecretResponse {
1826 #[allow(deprecated)]
1827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1828 where
1829 S: serde::Serializer,
1830 {
1831 use serde::ser::SerializeStruct;
1832 let mut len = 0;
1833 if self.version.is_some() {
1834 len += 1;
1835 }
1836 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSecretResponse", len)?;
1837 if let Some(v) = self.version.as_ref() {
1838 struct_ser.serialize_field("version", v)?;
1839 }
1840 struct_ser.end()
1841 }
1842}
1843impl<'de> serde::Deserialize<'de> for AlterSecretResponse {
1844 #[allow(deprecated)]
1845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1846 where
1847 D: serde::Deserializer<'de>,
1848 {
1849 const FIELDS: &[&str] = &[
1850 "version",
1851 ];
1852
1853 #[allow(clippy::enum_variant_names)]
1854 enum GeneratedField {
1855 Version,
1856 }
1857 impl<'de> serde::Deserialize<'de> for GeneratedField {
1858 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1859 where
1860 D: serde::Deserializer<'de>,
1861 {
1862 struct GeneratedVisitor;
1863
1864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1865 type Value = GeneratedField;
1866
1867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1868 write!(formatter, "expected one of: {:?}", &FIELDS)
1869 }
1870
1871 #[allow(unused_variables)]
1872 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1873 where
1874 E: serde::de::Error,
1875 {
1876 match value {
1877 "version" => Ok(GeneratedField::Version),
1878 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1879 }
1880 }
1881 }
1882 deserializer.deserialize_identifier(GeneratedVisitor)
1883 }
1884 }
1885 struct GeneratedVisitor;
1886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1887 type Value = AlterSecretResponse;
1888
1889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1890 formatter.write_str("struct ddl_service.AlterSecretResponse")
1891 }
1892
1893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSecretResponse, V::Error>
1894 where
1895 V: serde::de::MapAccess<'de>,
1896 {
1897 let mut version__ = None;
1898 while let Some(k) = map_.next_key()? {
1899 match k {
1900 GeneratedField::Version => {
1901 if version__.is_some() {
1902 return Err(serde::de::Error::duplicate_field("version"));
1903 }
1904 version__ = map_.next_value()?;
1905 }
1906 }
1907 }
1908 Ok(AlterSecretResponse {
1909 version: version__,
1910 })
1911 }
1912 }
1913 deserializer.deserialize_struct("ddl_service.AlterSecretResponse", FIELDS, GeneratedVisitor)
1914 }
1915}
1916impl serde::Serialize for AlterSetSchemaRequest {
1917 #[allow(deprecated)]
1918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1919 where
1920 S: serde::Serializer,
1921 {
1922 use serde::ser::SerializeStruct;
1923 let mut len = 0;
1924 if self.new_schema_id != 0 {
1925 len += 1;
1926 }
1927 if self.object.is_some() {
1928 len += 1;
1929 }
1930 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaRequest", len)?;
1931 if self.new_schema_id != 0 {
1932 struct_ser.serialize_field("newSchemaId", &self.new_schema_id)?;
1933 }
1934 if let Some(v) = self.object.as_ref() {
1935 match v {
1936 alter_set_schema_request::Object::TableId(v) => {
1937 struct_ser.serialize_field("tableId", v)?;
1938 }
1939 alter_set_schema_request::Object::ViewId(v) => {
1940 struct_ser.serialize_field("viewId", v)?;
1941 }
1942 alter_set_schema_request::Object::SourceId(v) => {
1943 struct_ser.serialize_field("sourceId", v)?;
1944 }
1945 alter_set_schema_request::Object::SinkId(v) => {
1946 struct_ser.serialize_field("sinkId", v)?;
1947 }
1948 alter_set_schema_request::Object::FunctionId(v) => {
1949 struct_ser.serialize_field("functionId", v)?;
1950 }
1951 alter_set_schema_request::Object::ConnectionId(v) => {
1952 struct_ser.serialize_field("connectionId", v)?;
1953 }
1954 alter_set_schema_request::Object::SubscriptionId(v) => {
1955 struct_ser.serialize_field("subscriptionId", v)?;
1956 }
1957 }
1958 }
1959 struct_ser.end()
1960 }
1961}
1962impl<'de> serde::Deserialize<'de> for AlterSetSchemaRequest {
1963 #[allow(deprecated)]
1964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1965 where
1966 D: serde::Deserializer<'de>,
1967 {
1968 const FIELDS: &[&str] = &[
1969 "new_schema_id",
1970 "newSchemaId",
1971 "table_id",
1972 "tableId",
1973 "view_id",
1974 "viewId",
1975 "source_id",
1976 "sourceId",
1977 "sink_id",
1978 "sinkId",
1979 "function_id",
1980 "functionId",
1981 "connection_id",
1982 "connectionId",
1983 "subscription_id",
1984 "subscriptionId",
1985 ];
1986
1987 #[allow(clippy::enum_variant_names)]
1988 enum GeneratedField {
1989 NewSchemaId,
1990 TableId,
1991 ViewId,
1992 SourceId,
1993 SinkId,
1994 FunctionId,
1995 ConnectionId,
1996 SubscriptionId,
1997 }
1998 impl<'de> serde::Deserialize<'de> for GeneratedField {
1999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2000 where
2001 D: serde::Deserializer<'de>,
2002 {
2003 struct GeneratedVisitor;
2004
2005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2006 type Value = GeneratedField;
2007
2008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2009 write!(formatter, "expected one of: {:?}", &FIELDS)
2010 }
2011
2012 #[allow(unused_variables)]
2013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2014 where
2015 E: serde::de::Error,
2016 {
2017 match value {
2018 "newSchemaId" | "new_schema_id" => Ok(GeneratedField::NewSchemaId),
2019 "tableId" | "table_id" => Ok(GeneratedField::TableId),
2020 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
2021 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
2022 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2023 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
2024 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
2025 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
2026 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2027 }
2028 }
2029 }
2030 deserializer.deserialize_identifier(GeneratedVisitor)
2031 }
2032 }
2033 struct GeneratedVisitor;
2034 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2035 type Value = AlterSetSchemaRequest;
2036
2037 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2038 formatter.write_str("struct ddl_service.AlterSetSchemaRequest")
2039 }
2040
2041 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaRequest, V::Error>
2042 where
2043 V: serde::de::MapAccess<'de>,
2044 {
2045 let mut new_schema_id__ = None;
2046 let mut object__ = None;
2047 while let Some(k) = map_.next_key()? {
2048 match k {
2049 GeneratedField::NewSchemaId => {
2050 if new_schema_id__.is_some() {
2051 return Err(serde::de::Error::duplicate_field("newSchemaId"));
2052 }
2053 new_schema_id__ =
2054 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2055 ;
2056 }
2057 GeneratedField::TableId => {
2058 if object__.is_some() {
2059 return Err(serde::de::Error::duplicate_field("tableId"));
2060 }
2061 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::TableId(x.0));
2062 }
2063 GeneratedField::ViewId => {
2064 if object__.is_some() {
2065 return Err(serde::de::Error::duplicate_field("viewId"));
2066 }
2067 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ViewId(x.0));
2068 }
2069 GeneratedField::SourceId => {
2070 if object__.is_some() {
2071 return Err(serde::de::Error::duplicate_field("sourceId"));
2072 }
2073 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SourceId(x.0));
2074 }
2075 GeneratedField::SinkId => {
2076 if object__.is_some() {
2077 return Err(serde::de::Error::duplicate_field("sinkId"));
2078 }
2079 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SinkId(x.0));
2080 }
2081 GeneratedField::FunctionId => {
2082 if object__.is_some() {
2083 return Err(serde::de::Error::duplicate_field("functionId"));
2084 }
2085 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::FunctionId(x.0));
2086 }
2087 GeneratedField::ConnectionId => {
2088 if object__.is_some() {
2089 return Err(serde::de::Error::duplicate_field("connectionId"));
2090 }
2091 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::ConnectionId(x.0));
2092 }
2093 GeneratedField::SubscriptionId => {
2094 if object__.is_some() {
2095 return Err(serde::de::Error::duplicate_field("subscriptionId"));
2096 }
2097 object__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| alter_set_schema_request::Object::SubscriptionId(x.0));
2098 }
2099 }
2100 }
2101 Ok(AlterSetSchemaRequest {
2102 new_schema_id: new_schema_id__.unwrap_or_default(),
2103 object: object__,
2104 })
2105 }
2106 }
2107 deserializer.deserialize_struct("ddl_service.AlterSetSchemaRequest", FIELDS, GeneratedVisitor)
2108 }
2109}
2110impl serde::Serialize for AlterSetSchemaResponse {
2111 #[allow(deprecated)]
2112 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2113 where
2114 S: serde::Serializer,
2115 {
2116 use serde::ser::SerializeStruct;
2117 let mut len = 0;
2118 if self.status.is_some() {
2119 len += 1;
2120 }
2121 if self.version.is_some() {
2122 len += 1;
2123 }
2124 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSetSchemaResponse", len)?;
2125 if let Some(v) = self.status.as_ref() {
2126 struct_ser.serialize_field("status", v)?;
2127 }
2128 if let Some(v) = self.version.as_ref() {
2129 struct_ser.serialize_field("version", v)?;
2130 }
2131 struct_ser.end()
2132 }
2133}
2134impl<'de> serde::Deserialize<'de> for AlterSetSchemaResponse {
2135 #[allow(deprecated)]
2136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2137 where
2138 D: serde::Deserializer<'de>,
2139 {
2140 const FIELDS: &[&str] = &[
2141 "status",
2142 "version",
2143 ];
2144
2145 #[allow(clippy::enum_variant_names)]
2146 enum GeneratedField {
2147 Status,
2148 Version,
2149 }
2150 impl<'de> serde::Deserialize<'de> for GeneratedField {
2151 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2152 where
2153 D: serde::Deserializer<'de>,
2154 {
2155 struct GeneratedVisitor;
2156
2157 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2158 type Value = GeneratedField;
2159
2160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2161 write!(formatter, "expected one of: {:?}", &FIELDS)
2162 }
2163
2164 #[allow(unused_variables)]
2165 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2166 where
2167 E: serde::de::Error,
2168 {
2169 match value {
2170 "status" => Ok(GeneratedField::Status),
2171 "version" => Ok(GeneratedField::Version),
2172 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2173 }
2174 }
2175 }
2176 deserializer.deserialize_identifier(GeneratedVisitor)
2177 }
2178 }
2179 struct GeneratedVisitor;
2180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2181 type Value = AlterSetSchemaResponse;
2182
2183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2184 formatter.write_str("struct ddl_service.AlterSetSchemaResponse")
2185 }
2186
2187 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSetSchemaResponse, V::Error>
2188 where
2189 V: serde::de::MapAccess<'de>,
2190 {
2191 let mut status__ = None;
2192 let mut version__ = None;
2193 while let Some(k) = map_.next_key()? {
2194 match k {
2195 GeneratedField::Status => {
2196 if status__.is_some() {
2197 return Err(serde::de::Error::duplicate_field("status"));
2198 }
2199 status__ = map_.next_value()?;
2200 }
2201 GeneratedField::Version => {
2202 if version__.is_some() {
2203 return Err(serde::de::Error::duplicate_field("version"));
2204 }
2205 version__ = map_.next_value()?;
2206 }
2207 }
2208 }
2209 Ok(AlterSetSchemaResponse {
2210 status: status__,
2211 version: version__,
2212 })
2213 }
2214 }
2215 deserializer.deserialize_struct("ddl_service.AlterSetSchemaResponse", FIELDS, GeneratedVisitor)
2216 }
2217}
2218impl serde::Serialize for AlterSourceRequest {
2219 #[allow(deprecated)]
2220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2221 where
2222 S: serde::Serializer,
2223 {
2224 use serde::ser::SerializeStruct;
2225 let mut len = 0;
2226 if self.source.is_some() {
2227 len += 1;
2228 }
2229 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceRequest", len)?;
2230 if let Some(v) = self.source.as_ref() {
2231 struct_ser.serialize_field("source", v)?;
2232 }
2233 struct_ser.end()
2234 }
2235}
2236impl<'de> serde::Deserialize<'de> for AlterSourceRequest {
2237 #[allow(deprecated)]
2238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2239 where
2240 D: serde::Deserializer<'de>,
2241 {
2242 const FIELDS: &[&str] = &[
2243 "source",
2244 ];
2245
2246 #[allow(clippy::enum_variant_names)]
2247 enum GeneratedField {
2248 Source,
2249 }
2250 impl<'de> serde::Deserialize<'de> for GeneratedField {
2251 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2252 where
2253 D: serde::Deserializer<'de>,
2254 {
2255 struct GeneratedVisitor;
2256
2257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2258 type Value = GeneratedField;
2259
2260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2261 write!(formatter, "expected one of: {:?}", &FIELDS)
2262 }
2263
2264 #[allow(unused_variables)]
2265 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2266 where
2267 E: serde::de::Error,
2268 {
2269 match value {
2270 "source" => Ok(GeneratedField::Source),
2271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2272 }
2273 }
2274 }
2275 deserializer.deserialize_identifier(GeneratedVisitor)
2276 }
2277 }
2278 struct GeneratedVisitor;
2279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2280 type Value = AlterSourceRequest;
2281
2282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2283 formatter.write_str("struct ddl_service.AlterSourceRequest")
2284 }
2285
2286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceRequest, V::Error>
2287 where
2288 V: serde::de::MapAccess<'de>,
2289 {
2290 let mut source__ = None;
2291 while let Some(k) = map_.next_key()? {
2292 match k {
2293 GeneratedField::Source => {
2294 if source__.is_some() {
2295 return Err(serde::de::Error::duplicate_field("source"));
2296 }
2297 source__ = map_.next_value()?;
2298 }
2299 }
2300 }
2301 Ok(AlterSourceRequest {
2302 source: source__,
2303 })
2304 }
2305 }
2306 deserializer.deserialize_struct("ddl_service.AlterSourceRequest", FIELDS, GeneratedVisitor)
2307 }
2308}
2309impl serde::Serialize for AlterSourceResponse {
2310 #[allow(deprecated)]
2311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2312 where
2313 S: serde::Serializer,
2314 {
2315 use serde::ser::SerializeStruct;
2316 let mut len = 0;
2317 if self.status.is_some() {
2318 len += 1;
2319 }
2320 if self.version.is_some() {
2321 len += 1;
2322 }
2323 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSourceResponse", len)?;
2324 if let Some(v) = self.status.as_ref() {
2325 struct_ser.serialize_field("status", v)?;
2326 }
2327 if let Some(v) = self.version.as_ref() {
2328 struct_ser.serialize_field("version", v)?;
2329 }
2330 struct_ser.end()
2331 }
2332}
2333impl<'de> serde::Deserialize<'de> for AlterSourceResponse {
2334 #[allow(deprecated)]
2335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2336 where
2337 D: serde::Deserializer<'de>,
2338 {
2339 const FIELDS: &[&str] = &[
2340 "status",
2341 "version",
2342 ];
2343
2344 #[allow(clippy::enum_variant_names)]
2345 enum GeneratedField {
2346 Status,
2347 Version,
2348 }
2349 impl<'de> serde::Deserialize<'de> for GeneratedField {
2350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2351 where
2352 D: serde::Deserializer<'de>,
2353 {
2354 struct GeneratedVisitor;
2355
2356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2357 type Value = GeneratedField;
2358
2359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2360 write!(formatter, "expected one of: {:?}", &FIELDS)
2361 }
2362
2363 #[allow(unused_variables)]
2364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2365 where
2366 E: serde::de::Error,
2367 {
2368 match value {
2369 "status" => Ok(GeneratedField::Status),
2370 "version" => Ok(GeneratedField::Version),
2371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2372 }
2373 }
2374 }
2375 deserializer.deserialize_identifier(GeneratedVisitor)
2376 }
2377 }
2378 struct GeneratedVisitor;
2379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2380 type Value = AlterSourceResponse;
2381
2382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2383 formatter.write_str("struct ddl_service.AlterSourceResponse")
2384 }
2385
2386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSourceResponse, V::Error>
2387 where
2388 V: serde::de::MapAccess<'de>,
2389 {
2390 let mut status__ = None;
2391 let mut version__ = None;
2392 while let Some(k) = map_.next_key()? {
2393 match k {
2394 GeneratedField::Status => {
2395 if status__.is_some() {
2396 return Err(serde::de::Error::duplicate_field("status"));
2397 }
2398 status__ = map_.next_value()?;
2399 }
2400 GeneratedField::Version => {
2401 if version__.is_some() {
2402 return Err(serde::de::Error::duplicate_field("version"));
2403 }
2404 version__ = map_.next_value()?;
2405 }
2406 }
2407 }
2408 Ok(AlterSourceResponse {
2409 status: status__,
2410 version: version__,
2411 })
2412 }
2413 }
2414 deserializer.deserialize_struct("ddl_service.AlterSourceResponse", FIELDS, GeneratedVisitor)
2415 }
2416}
2417impl serde::Serialize for AlterSwapRenameRequest {
2418 #[allow(deprecated)]
2419 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2420 where
2421 S: serde::Serializer,
2422 {
2423 use serde::ser::SerializeStruct;
2424 let mut len = 0;
2425 if self.object.is_some() {
2426 len += 1;
2427 }
2428 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest", len)?;
2429 if let Some(v) = self.object.as_ref() {
2430 match v {
2431 alter_swap_rename_request::Object::Schema(v) => {
2432 struct_ser.serialize_field("schema", v)?;
2433 }
2434 alter_swap_rename_request::Object::Table(v) => {
2435 struct_ser.serialize_field("table", v)?;
2436 }
2437 alter_swap_rename_request::Object::View(v) => {
2438 struct_ser.serialize_field("view", v)?;
2439 }
2440 alter_swap_rename_request::Object::Source(v) => {
2441 struct_ser.serialize_field("source", v)?;
2442 }
2443 alter_swap_rename_request::Object::Sink(v) => {
2444 struct_ser.serialize_field("sink", v)?;
2445 }
2446 alter_swap_rename_request::Object::Subscription(v) => {
2447 struct_ser.serialize_field("subscription", v)?;
2448 }
2449 }
2450 }
2451 struct_ser.end()
2452 }
2453}
2454impl<'de> serde::Deserialize<'de> for AlterSwapRenameRequest {
2455 #[allow(deprecated)]
2456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2457 where
2458 D: serde::Deserializer<'de>,
2459 {
2460 const FIELDS: &[&str] = &[
2461 "schema",
2462 "table",
2463 "view",
2464 "source",
2465 "sink",
2466 "subscription",
2467 ];
2468
2469 #[allow(clippy::enum_variant_names)]
2470 enum GeneratedField {
2471 Schema,
2472 Table,
2473 View,
2474 Source,
2475 Sink,
2476 Subscription,
2477 }
2478 impl<'de> serde::Deserialize<'de> for GeneratedField {
2479 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2480 where
2481 D: serde::Deserializer<'de>,
2482 {
2483 struct GeneratedVisitor;
2484
2485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2486 type Value = GeneratedField;
2487
2488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2489 write!(formatter, "expected one of: {:?}", &FIELDS)
2490 }
2491
2492 #[allow(unused_variables)]
2493 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2494 where
2495 E: serde::de::Error,
2496 {
2497 match value {
2498 "schema" => Ok(GeneratedField::Schema),
2499 "table" => Ok(GeneratedField::Table),
2500 "view" => Ok(GeneratedField::View),
2501 "source" => Ok(GeneratedField::Source),
2502 "sink" => Ok(GeneratedField::Sink),
2503 "subscription" => Ok(GeneratedField::Subscription),
2504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2505 }
2506 }
2507 }
2508 deserializer.deserialize_identifier(GeneratedVisitor)
2509 }
2510 }
2511 struct GeneratedVisitor;
2512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2513 type Value = AlterSwapRenameRequest;
2514
2515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2516 formatter.write_str("struct ddl_service.AlterSwapRenameRequest")
2517 }
2518
2519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameRequest, V::Error>
2520 where
2521 V: serde::de::MapAccess<'de>,
2522 {
2523 let mut object__ = None;
2524 while let Some(k) = map_.next_key()? {
2525 match k {
2526 GeneratedField::Schema => {
2527 if object__.is_some() {
2528 return Err(serde::de::Error::duplicate_field("schema"));
2529 }
2530 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Schema)
2531;
2532 }
2533 GeneratedField::Table => {
2534 if object__.is_some() {
2535 return Err(serde::de::Error::duplicate_field("table"));
2536 }
2537 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Table)
2538;
2539 }
2540 GeneratedField::View => {
2541 if object__.is_some() {
2542 return Err(serde::de::Error::duplicate_field("view"));
2543 }
2544 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::View)
2545;
2546 }
2547 GeneratedField::Source => {
2548 if object__.is_some() {
2549 return Err(serde::de::Error::duplicate_field("source"));
2550 }
2551 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Source)
2552;
2553 }
2554 GeneratedField::Sink => {
2555 if object__.is_some() {
2556 return Err(serde::de::Error::duplicate_field("sink"));
2557 }
2558 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Sink)
2559;
2560 }
2561 GeneratedField::Subscription => {
2562 if object__.is_some() {
2563 return Err(serde::de::Error::duplicate_field("subscription"));
2564 }
2565 object__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_swap_rename_request::Object::Subscription)
2566;
2567 }
2568 }
2569 }
2570 Ok(AlterSwapRenameRequest {
2571 object: object__,
2572 })
2573 }
2574 }
2575 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest", FIELDS, GeneratedVisitor)
2576 }
2577}
2578impl serde::Serialize for alter_swap_rename_request::ObjectNameSwapPair {
2579 #[allow(deprecated)]
2580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2581 where
2582 S: serde::Serializer,
2583 {
2584 use serde::ser::SerializeStruct;
2585 let mut len = 0;
2586 if self.src_object_id != 0 {
2587 len += 1;
2588 }
2589 if self.dst_object_id != 0 {
2590 len += 1;
2591 }
2592 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", len)?;
2593 if self.src_object_id != 0 {
2594 struct_ser.serialize_field("srcObjectId", &self.src_object_id)?;
2595 }
2596 if self.dst_object_id != 0 {
2597 struct_ser.serialize_field("dstObjectId", &self.dst_object_id)?;
2598 }
2599 struct_ser.end()
2600 }
2601}
2602impl<'de> serde::Deserialize<'de> for alter_swap_rename_request::ObjectNameSwapPair {
2603 #[allow(deprecated)]
2604 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2605 where
2606 D: serde::Deserializer<'de>,
2607 {
2608 const FIELDS: &[&str] = &[
2609 "src_object_id",
2610 "srcObjectId",
2611 "dst_object_id",
2612 "dstObjectId",
2613 ];
2614
2615 #[allow(clippy::enum_variant_names)]
2616 enum GeneratedField {
2617 SrcObjectId,
2618 DstObjectId,
2619 }
2620 impl<'de> serde::Deserialize<'de> for GeneratedField {
2621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2622 where
2623 D: serde::Deserializer<'de>,
2624 {
2625 struct GeneratedVisitor;
2626
2627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2628 type Value = GeneratedField;
2629
2630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2631 write!(formatter, "expected one of: {:?}", &FIELDS)
2632 }
2633
2634 #[allow(unused_variables)]
2635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2636 where
2637 E: serde::de::Error,
2638 {
2639 match value {
2640 "srcObjectId" | "src_object_id" => Ok(GeneratedField::SrcObjectId),
2641 "dstObjectId" | "dst_object_id" => Ok(GeneratedField::DstObjectId),
2642 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2643 }
2644 }
2645 }
2646 deserializer.deserialize_identifier(GeneratedVisitor)
2647 }
2648 }
2649 struct GeneratedVisitor;
2650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2651 type Value = alter_swap_rename_request::ObjectNameSwapPair;
2652
2653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2654 formatter.write_str("struct ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair")
2655 }
2656
2657 fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_swap_rename_request::ObjectNameSwapPair, V::Error>
2658 where
2659 V: serde::de::MapAccess<'de>,
2660 {
2661 let mut src_object_id__ = None;
2662 let mut dst_object_id__ = None;
2663 while let Some(k) = map_.next_key()? {
2664 match k {
2665 GeneratedField::SrcObjectId => {
2666 if src_object_id__.is_some() {
2667 return Err(serde::de::Error::duplicate_field("srcObjectId"));
2668 }
2669 src_object_id__ =
2670 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2671 ;
2672 }
2673 GeneratedField::DstObjectId => {
2674 if dst_object_id__.is_some() {
2675 return Err(serde::de::Error::duplicate_field("dstObjectId"));
2676 }
2677 dst_object_id__ =
2678 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2679 ;
2680 }
2681 }
2682 }
2683 Ok(alter_swap_rename_request::ObjectNameSwapPair {
2684 src_object_id: src_object_id__.unwrap_or_default(),
2685 dst_object_id: dst_object_id__.unwrap_or_default(),
2686 })
2687 }
2688 }
2689 deserializer.deserialize_struct("ddl_service.AlterSwapRenameRequest.ObjectNameSwapPair", FIELDS, GeneratedVisitor)
2690 }
2691}
2692impl serde::Serialize for AlterSwapRenameResponse {
2693 #[allow(deprecated)]
2694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2695 where
2696 S: serde::Serializer,
2697 {
2698 use serde::ser::SerializeStruct;
2699 let mut len = 0;
2700 if self.status.is_some() {
2701 len += 1;
2702 }
2703 if self.version.is_some() {
2704 len += 1;
2705 }
2706 let mut struct_ser = serializer.serialize_struct("ddl_service.AlterSwapRenameResponse", len)?;
2707 if let Some(v) = self.status.as_ref() {
2708 struct_ser.serialize_field("status", v)?;
2709 }
2710 if let Some(v) = self.version.as_ref() {
2711 struct_ser.serialize_field("version", v)?;
2712 }
2713 struct_ser.end()
2714 }
2715}
2716impl<'de> serde::Deserialize<'de> for AlterSwapRenameResponse {
2717 #[allow(deprecated)]
2718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2719 where
2720 D: serde::Deserializer<'de>,
2721 {
2722 const FIELDS: &[&str] = &[
2723 "status",
2724 "version",
2725 ];
2726
2727 #[allow(clippy::enum_variant_names)]
2728 enum GeneratedField {
2729 Status,
2730 Version,
2731 }
2732 impl<'de> serde::Deserialize<'de> for GeneratedField {
2733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2734 where
2735 D: serde::Deserializer<'de>,
2736 {
2737 struct GeneratedVisitor;
2738
2739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2740 type Value = GeneratedField;
2741
2742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2743 write!(formatter, "expected one of: {:?}", &FIELDS)
2744 }
2745
2746 #[allow(unused_variables)]
2747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2748 where
2749 E: serde::de::Error,
2750 {
2751 match value {
2752 "status" => Ok(GeneratedField::Status),
2753 "version" => Ok(GeneratedField::Version),
2754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2755 }
2756 }
2757 }
2758 deserializer.deserialize_identifier(GeneratedVisitor)
2759 }
2760 }
2761 struct GeneratedVisitor;
2762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2763 type Value = AlterSwapRenameResponse;
2764
2765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2766 formatter.write_str("struct ddl_service.AlterSwapRenameResponse")
2767 }
2768
2769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterSwapRenameResponse, V::Error>
2770 where
2771 V: serde::de::MapAccess<'de>,
2772 {
2773 let mut status__ = None;
2774 let mut version__ = None;
2775 while let Some(k) = map_.next_key()? {
2776 match k {
2777 GeneratedField::Status => {
2778 if status__.is_some() {
2779 return Err(serde::de::Error::duplicate_field("status"));
2780 }
2781 status__ = map_.next_value()?;
2782 }
2783 GeneratedField::Version => {
2784 if version__.is_some() {
2785 return Err(serde::de::Error::duplicate_field("version"));
2786 }
2787 version__ = map_.next_value()?;
2788 }
2789 }
2790 }
2791 Ok(AlterSwapRenameResponse {
2792 status: status__,
2793 version: version__,
2794 })
2795 }
2796 }
2797 deserializer.deserialize_struct("ddl_service.AlterSwapRenameResponse", FIELDS, GeneratedVisitor)
2798 }
2799}
2800impl serde::Serialize for AutoSchemaChangeRequest {
2801 #[allow(deprecated)]
2802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2803 where
2804 S: serde::Serializer,
2805 {
2806 use serde::ser::SerializeStruct;
2807 let mut len = 0;
2808 if self.schema_change.is_some() {
2809 len += 1;
2810 }
2811 let mut struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeRequest", len)?;
2812 if let Some(v) = self.schema_change.as_ref() {
2813 struct_ser.serialize_field("schemaChange", v)?;
2814 }
2815 struct_ser.end()
2816 }
2817}
2818impl<'de> serde::Deserialize<'de> for AutoSchemaChangeRequest {
2819 #[allow(deprecated)]
2820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2821 where
2822 D: serde::Deserializer<'de>,
2823 {
2824 const FIELDS: &[&str] = &[
2825 "schema_change",
2826 "schemaChange",
2827 ];
2828
2829 #[allow(clippy::enum_variant_names)]
2830 enum GeneratedField {
2831 SchemaChange,
2832 }
2833 impl<'de> serde::Deserialize<'de> for GeneratedField {
2834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2835 where
2836 D: serde::Deserializer<'de>,
2837 {
2838 struct GeneratedVisitor;
2839
2840 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2841 type Value = GeneratedField;
2842
2843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2844 write!(formatter, "expected one of: {:?}", &FIELDS)
2845 }
2846
2847 #[allow(unused_variables)]
2848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2849 where
2850 E: serde::de::Error,
2851 {
2852 match value {
2853 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
2854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2855 }
2856 }
2857 }
2858 deserializer.deserialize_identifier(GeneratedVisitor)
2859 }
2860 }
2861 struct GeneratedVisitor;
2862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2863 type Value = AutoSchemaChangeRequest;
2864
2865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2866 formatter.write_str("struct ddl_service.AutoSchemaChangeRequest")
2867 }
2868
2869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeRequest, V::Error>
2870 where
2871 V: serde::de::MapAccess<'de>,
2872 {
2873 let mut schema_change__ = None;
2874 while let Some(k) = map_.next_key()? {
2875 match k {
2876 GeneratedField::SchemaChange => {
2877 if schema_change__.is_some() {
2878 return Err(serde::de::Error::duplicate_field("schemaChange"));
2879 }
2880 schema_change__ = map_.next_value()?;
2881 }
2882 }
2883 }
2884 Ok(AutoSchemaChangeRequest {
2885 schema_change: schema_change__,
2886 })
2887 }
2888 }
2889 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeRequest", FIELDS, GeneratedVisitor)
2890 }
2891}
2892impl serde::Serialize for AutoSchemaChangeResponse {
2893 #[allow(deprecated)]
2894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2895 where
2896 S: serde::Serializer,
2897 {
2898 use serde::ser::SerializeStruct;
2899 let len = 0;
2900 let struct_ser = serializer.serialize_struct("ddl_service.AutoSchemaChangeResponse", len)?;
2901 struct_ser.end()
2902 }
2903}
2904impl<'de> serde::Deserialize<'de> for AutoSchemaChangeResponse {
2905 #[allow(deprecated)]
2906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2907 where
2908 D: serde::Deserializer<'de>,
2909 {
2910 const FIELDS: &[&str] = &[
2911 ];
2912
2913 #[allow(clippy::enum_variant_names)]
2914 enum GeneratedField {
2915 }
2916 impl<'de> serde::Deserialize<'de> for GeneratedField {
2917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2918 where
2919 D: serde::Deserializer<'de>,
2920 {
2921 struct GeneratedVisitor;
2922
2923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2924 type Value = GeneratedField;
2925
2926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2927 write!(formatter, "expected one of: {:?}", &FIELDS)
2928 }
2929
2930 #[allow(unused_variables)]
2931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2932 where
2933 E: serde::de::Error,
2934 {
2935 Err(serde::de::Error::unknown_field(value, FIELDS))
2936 }
2937 }
2938 deserializer.deserialize_identifier(GeneratedVisitor)
2939 }
2940 }
2941 struct GeneratedVisitor;
2942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2943 type Value = AutoSchemaChangeResponse;
2944
2945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2946 formatter.write_str("struct ddl_service.AutoSchemaChangeResponse")
2947 }
2948
2949 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoSchemaChangeResponse, V::Error>
2950 where
2951 V: serde::de::MapAccess<'de>,
2952 {
2953 while map_.next_key::<GeneratedField>()?.is_some() {
2954 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2955 }
2956 Ok(AutoSchemaChangeResponse {
2957 })
2958 }
2959 }
2960 deserializer.deserialize_struct("ddl_service.AutoSchemaChangeResponse", FIELDS, GeneratedVisitor)
2961 }
2962}
2963impl serde::Serialize for CommentOnRequest {
2964 #[allow(deprecated)]
2965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2966 where
2967 S: serde::Serializer,
2968 {
2969 use serde::ser::SerializeStruct;
2970 let mut len = 0;
2971 if self.comment.is_some() {
2972 len += 1;
2973 }
2974 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnRequest", len)?;
2975 if let Some(v) = self.comment.as_ref() {
2976 struct_ser.serialize_field("comment", v)?;
2977 }
2978 struct_ser.end()
2979 }
2980}
2981impl<'de> serde::Deserialize<'de> for CommentOnRequest {
2982 #[allow(deprecated)]
2983 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2984 where
2985 D: serde::Deserializer<'de>,
2986 {
2987 const FIELDS: &[&str] = &[
2988 "comment",
2989 ];
2990
2991 #[allow(clippy::enum_variant_names)]
2992 enum GeneratedField {
2993 Comment,
2994 }
2995 impl<'de> serde::Deserialize<'de> for GeneratedField {
2996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2997 where
2998 D: serde::Deserializer<'de>,
2999 {
3000 struct GeneratedVisitor;
3001
3002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3003 type Value = GeneratedField;
3004
3005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3006 write!(formatter, "expected one of: {:?}", &FIELDS)
3007 }
3008
3009 #[allow(unused_variables)]
3010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3011 where
3012 E: serde::de::Error,
3013 {
3014 match value {
3015 "comment" => Ok(GeneratedField::Comment),
3016 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3017 }
3018 }
3019 }
3020 deserializer.deserialize_identifier(GeneratedVisitor)
3021 }
3022 }
3023 struct GeneratedVisitor;
3024 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3025 type Value = CommentOnRequest;
3026
3027 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3028 formatter.write_str("struct ddl_service.CommentOnRequest")
3029 }
3030
3031 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnRequest, V::Error>
3032 where
3033 V: serde::de::MapAccess<'de>,
3034 {
3035 let mut comment__ = None;
3036 while let Some(k) = map_.next_key()? {
3037 match k {
3038 GeneratedField::Comment => {
3039 if comment__.is_some() {
3040 return Err(serde::de::Error::duplicate_field("comment"));
3041 }
3042 comment__ = map_.next_value()?;
3043 }
3044 }
3045 }
3046 Ok(CommentOnRequest {
3047 comment: comment__,
3048 })
3049 }
3050 }
3051 deserializer.deserialize_struct("ddl_service.CommentOnRequest", FIELDS, GeneratedVisitor)
3052 }
3053}
3054impl serde::Serialize for CommentOnResponse {
3055 #[allow(deprecated)]
3056 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3057 where
3058 S: serde::Serializer,
3059 {
3060 use serde::ser::SerializeStruct;
3061 let mut len = 0;
3062 if self.status.is_some() {
3063 len += 1;
3064 }
3065 if self.version.is_some() {
3066 len += 1;
3067 }
3068 let mut struct_ser = serializer.serialize_struct("ddl_service.CommentOnResponse", len)?;
3069 if let Some(v) = self.status.as_ref() {
3070 struct_ser.serialize_field("status", v)?;
3071 }
3072 if let Some(v) = self.version.as_ref() {
3073 struct_ser.serialize_field("version", v)?;
3074 }
3075 struct_ser.end()
3076 }
3077}
3078impl<'de> serde::Deserialize<'de> for CommentOnResponse {
3079 #[allow(deprecated)]
3080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3081 where
3082 D: serde::Deserializer<'de>,
3083 {
3084 const FIELDS: &[&str] = &[
3085 "status",
3086 "version",
3087 ];
3088
3089 #[allow(clippy::enum_variant_names)]
3090 enum GeneratedField {
3091 Status,
3092 Version,
3093 }
3094 impl<'de> serde::Deserialize<'de> for GeneratedField {
3095 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3096 where
3097 D: serde::Deserializer<'de>,
3098 {
3099 struct GeneratedVisitor;
3100
3101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3102 type Value = GeneratedField;
3103
3104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3105 write!(formatter, "expected one of: {:?}", &FIELDS)
3106 }
3107
3108 #[allow(unused_variables)]
3109 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3110 where
3111 E: serde::de::Error,
3112 {
3113 match value {
3114 "status" => Ok(GeneratedField::Status),
3115 "version" => Ok(GeneratedField::Version),
3116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3117 }
3118 }
3119 }
3120 deserializer.deserialize_identifier(GeneratedVisitor)
3121 }
3122 }
3123 struct GeneratedVisitor;
3124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3125 type Value = CommentOnResponse;
3126
3127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3128 formatter.write_str("struct ddl_service.CommentOnResponse")
3129 }
3130
3131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentOnResponse, V::Error>
3132 where
3133 V: serde::de::MapAccess<'de>,
3134 {
3135 let mut status__ = None;
3136 let mut version__ = None;
3137 while let Some(k) = map_.next_key()? {
3138 match k {
3139 GeneratedField::Status => {
3140 if status__.is_some() {
3141 return Err(serde::de::Error::duplicate_field("status"));
3142 }
3143 status__ = map_.next_value()?;
3144 }
3145 GeneratedField::Version => {
3146 if version__.is_some() {
3147 return Err(serde::de::Error::duplicate_field("version"));
3148 }
3149 version__ = map_.next_value()?;
3150 }
3151 }
3152 }
3153 Ok(CommentOnResponse {
3154 status: status__,
3155 version: version__,
3156 })
3157 }
3158 }
3159 deserializer.deserialize_struct("ddl_service.CommentOnResponse", FIELDS, GeneratedVisitor)
3160 }
3161}
3162impl serde::Serialize for CompactIcebergTableRequest {
3163 #[allow(deprecated)]
3164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3165 where
3166 S: serde::Serializer,
3167 {
3168 use serde::ser::SerializeStruct;
3169 let mut len = 0;
3170 if self.sink_id != 0 {
3171 len += 1;
3172 }
3173 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableRequest", len)?;
3174 if self.sink_id != 0 {
3175 struct_ser.serialize_field("sinkId", &self.sink_id)?;
3176 }
3177 struct_ser.end()
3178 }
3179}
3180impl<'de> serde::Deserialize<'de> for CompactIcebergTableRequest {
3181 #[allow(deprecated)]
3182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3183 where
3184 D: serde::Deserializer<'de>,
3185 {
3186 const FIELDS: &[&str] = &[
3187 "sink_id",
3188 "sinkId",
3189 ];
3190
3191 #[allow(clippy::enum_variant_names)]
3192 enum GeneratedField {
3193 SinkId,
3194 }
3195 impl<'de> serde::Deserialize<'de> for GeneratedField {
3196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3197 where
3198 D: serde::Deserializer<'de>,
3199 {
3200 struct GeneratedVisitor;
3201
3202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3203 type Value = GeneratedField;
3204
3205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3206 write!(formatter, "expected one of: {:?}", &FIELDS)
3207 }
3208
3209 #[allow(unused_variables)]
3210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3211 where
3212 E: serde::de::Error,
3213 {
3214 match value {
3215 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
3216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3217 }
3218 }
3219 }
3220 deserializer.deserialize_identifier(GeneratedVisitor)
3221 }
3222 }
3223 struct GeneratedVisitor;
3224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3225 type Value = CompactIcebergTableRequest;
3226
3227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3228 formatter.write_str("struct ddl_service.CompactIcebergTableRequest")
3229 }
3230
3231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableRequest, V::Error>
3232 where
3233 V: serde::de::MapAccess<'de>,
3234 {
3235 let mut sink_id__ = None;
3236 while let Some(k) = map_.next_key()? {
3237 match k {
3238 GeneratedField::SinkId => {
3239 if sink_id__.is_some() {
3240 return Err(serde::de::Error::duplicate_field("sinkId"));
3241 }
3242 sink_id__ =
3243 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3244 ;
3245 }
3246 }
3247 }
3248 Ok(CompactIcebergTableRequest {
3249 sink_id: sink_id__.unwrap_or_default(),
3250 })
3251 }
3252 }
3253 deserializer.deserialize_struct("ddl_service.CompactIcebergTableRequest", FIELDS, GeneratedVisitor)
3254 }
3255}
3256impl serde::Serialize for CompactIcebergTableResponse {
3257 #[allow(deprecated)]
3258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3259 where
3260 S: serde::Serializer,
3261 {
3262 use serde::ser::SerializeStruct;
3263 let mut len = 0;
3264 if self.status.is_some() {
3265 len += 1;
3266 }
3267 if self.task_id != 0 {
3268 len += 1;
3269 }
3270 let mut struct_ser = serializer.serialize_struct("ddl_service.CompactIcebergTableResponse", len)?;
3271 if let Some(v) = self.status.as_ref() {
3272 struct_ser.serialize_field("status", v)?;
3273 }
3274 if self.task_id != 0 {
3275 #[allow(clippy::needless_borrow)]
3276 #[allow(clippy::needless_borrows_for_generic_args)]
3277 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
3278 }
3279 struct_ser.end()
3280 }
3281}
3282impl<'de> serde::Deserialize<'de> for CompactIcebergTableResponse {
3283 #[allow(deprecated)]
3284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3285 where
3286 D: serde::Deserializer<'de>,
3287 {
3288 const FIELDS: &[&str] = &[
3289 "status",
3290 "task_id",
3291 "taskId",
3292 ];
3293
3294 #[allow(clippy::enum_variant_names)]
3295 enum GeneratedField {
3296 Status,
3297 TaskId,
3298 }
3299 impl<'de> serde::Deserialize<'de> for GeneratedField {
3300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3301 where
3302 D: serde::Deserializer<'de>,
3303 {
3304 struct GeneratedVisitor;
3305
3306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3307 type Value = GeneratedField;
3308
3309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3310 write!(formatter, "expected one of: {:?}", &FIELDS)
3311 }
3312
3313 #[allow(unused_variables)]
3314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3315 where
3316 E: serde::de::Error,
3317 {
3318 match value {
3319 "status" => Ok(GeneratedField::Status),
3320 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
3321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3322 }
3323 }
3324 }
3325 deserializer.deserialize_identifier(GeneratedVisitor)
3326 }
3327 }
3328 struct GeneratedVisitor;
3329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3330 type Value = CompactIcebergTableResponse;
3331
3332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3333 formatter.write_str("struct ddl_service.CompactIcebergTableResponse")
3334 }
3335
3336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactIcebergTableResponse, V::Error>
3337 where
3338 V: serde::de::MapAccess<'de>,
3339 {
3340 let mut status__ = None;
3341 let mut task_id__ = None;
3342 while let Some(k) = map_.next_key()? {
3343 match k {
3344 GeneratedField::Status => {
3345 if status__.is_some() {
3346 return Err(serde::de::Error::duplicate_field("status"));
3347 }
3348 status__ = map_.next_value()?;
3349 }
3350 GeneratedField::TaskId => {
3351 if task_id__.is_some() {
3352 return Err(serde::de::Error::duplicate_field("taskId"));
3353 }
3354 task_id__ =
3355 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3356 ;
3357 }
3358 }
3359 }
3360 Ok(CompactIcebergTableResponse {
3361 status: status__,
3362 task_id: task_id__.unwrap_or_default(),
3363 })
3364 }
3365 }
3366 deserializer.deserialize_struct("ddl_service.CompactIcebergTableResponse", FIELDS, GeneratedVisitor)
3367 }
3368}
3369impl serde::Serialize for CreateConnectionRequest {
3370 #[allow(deprecated)]
3371 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3372 where
3373 S: serde::Serializer,
3374 {
3375 use serde::ser::SerializeStruct;
3376 let mut len = 0;
3377 if !self.name.is_empty() {
3378 len += 1;
3379 }
3380 if self.database_id != 0 {
3381 len += 1;
3382 }
3383 if self.schema_id != 0 {
3384 len += 1;
3385 }
3386 if self.owner_id != 0 {
3387 len += 1;
3388 }
3389 if self.payload.is_some() {
3390 len += 1;
3391 }
3392 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest", len)?;
3393 if !self.name.is_empty() {
3394 struct_ser.serialize_field("name", &self.name)?;
3395 }
3396 if self.database_id != 0 {
3397 struct_ser.serialize_field("databaseId", &self.database_id)?;
3398 }
3399 if self.schema_id != 0 {
3400 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3401 }
3402 if self.owner_id != 0 {
3403 struct_ser.serialize_field("ownerId", &self.owner_id)?;
3404 }
3405 if let Some(v) = self.payload.as_ref() {
3406 match v {
3407 create_connection_request::Payload::PrivateLink(v) => {
3408 struct_ser.serialize_field("privateLink", v)?;
3409 }
3410 create_connection_request::Payload::ConnectionParams(v) => {
3411 struct_ser.serialize_field("connectionParams", v)?;
3412 }
3413 }
3414 }
3415 struct_ser.end()
3416 }
3417}
3418impl<'de> serde::Deserialize<'de> for CreateConnectionRequest {
3419 #[allow(deprecated)]
3420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3421 where
3422 D: serde::Deserializer<'de>,
3423 {
3424 const FIELDS: &[&str] = &[
3425 "name",
3426 "database_id",
3427 "databaseId",
3428 "schema_id",
3429 "schemaId",
3430 "owner_id",
3431 "ownerId",
3432 "private_link",
3433 "privateLink",
3434 "connection_params",
3435 "connectionParams",
3436 ];
3437
3438 #[allow(clippy::enum_variant_names)]
3439 enum GeneratedField {
3440 Name,
3441 DatabaseId,
3442 SchemaId,
3443 OwnerId,
3444 PrivateLink,
3445 ConnectionParams,
3446 }
3447 impl<'de> serde::Deserialize<'de> for GeneratedField {
3448 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3449 where
3450 D: serde::Deserializer<'de>,
3451 {
3452 struct GeneratedVisitor;
3453
3454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3455 type Value = GeneratedField;
3456
3457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3458 write!(formatter, "expected one of: {:?}", &FIELDS)
3459 }
3460
3461 #[allow(unused_variables)]
3462 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3463 where
3464 E: serde::de::Error,
3465 {
3466 match value {
3467 "name" => Ok(GeneratedField::Name),
3468 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3469 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3470 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
3471 "privateLink" | "private_link" => Ok(GeneratedField::PrivateLink),
3472 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
3473 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3474 }
3475 }
3476 }
3477 deserializer.deserialize_identifier(GeneratedVisitor)
3478 }
3479 }
3480 struct GeneratedVisitor;
3481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3482 type Value = CreateConnectionRequest;
3483
3484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3485 formatter.write_str("struct ddl_service.CreateConnectionRequest")
3486 }
3487
3488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionRequest, V::Error>
3489 where
3490 V: serde::de::MapAccess<'de>,
3491 {
3492 let mut name__ = None;
3493 let mut database_id__ = None;
3494 let mut schema_id__ = None;
3495 let mut owner_id__ = None;
3496 let mut payload__ = None;
3497 while let Some(k) = map_.next_key()? {
3498 match k {
3499 GeneratedField::Name => {
3500 if name__.is_some() {
3501 return Err(serde::de::Error::duplicate_field("name"));
3502 }
3503 name__ = Some(map_.next_value()?);
3504 }
3505 GeneratedField::DatabaseId => {
3506 if database_id__.is_some() {
3507 return Err(serde::de::Error::duplicate_field("databaseId"));
3508 }
3509 database_id__ =
3510 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3511 ;
3512 }
3513 GeneratedField::SchemaId => {
3514 if schema_id__.is_some() {
3515 return Err(serde::de::Error::duplicate_field("schemaId"));
3516 }
3517 schema_id__ =
3518 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3519 ;
3520 }
3521 GeneratedField::OwnerId => {
3522 if owner_id__.is_some() {
3523 return Err(serde::de::Error::duplicate_field("ownerId"));
3524 }
3525 owner_id__ =
3526 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3527 ;
3528 }
3529 GeneratedField::PrivateLink => {
3530 if payload__.is_some() {
3531 return Err(serde::de::Error::duplicate_field("privateLink"));
3532 }
3533 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::PrivateLink)
3534;
3535 }
3536 GeneratedField::ConnectionParams => {
3537 if payload__.is_some() {
3538 return Err(serde::de::Error::duplicate_field("connectionParams"));
3539 }
3540 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(create_connection_request::Payload::ConnectionParams)
3541;
3542 }
3543 }
3544 }
3545 Ok(CreateConnectionRequest {
3546 name: name__.unwrap_or_default(),
3547 database_id: database_id__.unwrap_or_default(),
3548 schema_id: schema_id__.unwrap_or_default(),
3549 owner_id: owner_id__.unwrap_or_default(),
3550 payload: payload__,
3551 })
3552 }
3553 }
3554 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest", FIELDS, GeneratedVisitor)
3555 }
3556}
3557impl serde::Serialize for create_connection_request::PrivateLink {
3558 #[allow(deprecated)]
3559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3560 where
3561 S: serde::Serializer,
3562 {
3563 use serde::ser::SerializeStruct;
3564 let mut len = 0;
3565 if self.provider != 0 {
3566 len += 1;
3567 }
3568 if !self.service_name.is_empty() {
3569 len += 1;
3570 }
3571 if self.tags.is_some() {
3572 len += 1;
3573 }
3574 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", len)?;
3575 if self.provider != 0 {
3576 let v = super::catalog::connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
3577 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
3578 struct_ser.serialize_field("provider", &v)?;
3579 }
3580 if !self.service_name.is_empty() {
3581 struct_ser.serialize_field("serviceName", &self.service_name)?;
3582 }
3583 if let Some(v) = self.tags.as_ref() {
3584 struct_ser.serialize_field("tags", v)?;
3585 }
3586 struct_ser.end()
3587 }
3588}
3589impl<'de> serde::Deserialize<'de> for create_connection_request::PrivateLink {
3590 #[allow(deprecated)]
3591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3592 where
3593 D: serde::Deserializer<'de>,
3594 {
3595 const FIELDS: &[&str] = &[
3596 "provider",
3597 "service_name",
3598 "serviceName",
3599 "tags",
3600 ];
3601
3602 #[allow(clippy::enum_variant_names)]
3603 enum GeneratedField {
3604 Provider,
3605 ServiceName,
3606 Tags,
3607 }
3608 impl<'de> serde::Deserialize<'de> for GeneratedField {
3609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3610 where
3611 D: serde::Deserializer<'de>,
3612 {
3613 struct GeneratedVisitor;
3614
3615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3616 type Value = GeneratedField;
3617
3618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3619 write!(formatter, "expected one of: {:?}", &FIELDS)
3620 }
3621
3622 #[allow(unused_variables)]
3623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3624 where
3625 E: serde::de::Error,
3626 {
3627 match value {
3628 "provider" => Ok(GeneratedField::Provider),
3629 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
3630 "tags" => Ok(GeneratedField::Tags),
3631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632 }
3633 }
3634 }
3635 deserializer.deserialize_identifier(GeneratedVisitor)
3636 }
3637 }
3638 struct GeneratedVisitor;
3639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640 type Value = create_connection_request::PrivateLink;
3641
3642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643 formatter.write_str("struct ddl_service.CreateConnectionRequest.PrivateLink")
3644 }
3645
3646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_connection_request::PrivateLink, V::Error>
3647 where
3648 V: serde::de::MapAccess<'de>,
3649 {
3650 let mut provider__ = None;
3651 let mut service_name__ = None;
3652 let mut tags__ = None;
3653 while let Some(k) = map_.next_key()? {
3654 match k {
3655 GeneratedField::Provider => {
3656 if provider__.is_some() {
3657 return Err(serde::de::Error::duplicate_field("provider"));
3658 }
3659 provider__ = Some(map_.next_value::<super::catalog::connection::private_link_service::PrivateLinkProvider>()? as i32);
3660 }
3661 GeneratedField::ServiceName => {
3662 if service_name__.is_some() {
3663 return Err(serde::de::Error::duplicate_field("serviceName"));
3664 }
3665 service_name__ = Some(map_.next_value()?);
3666 }
3667 GeneratedField::Tags => {
3668 if tags__.is_some() {
3669 return Err(serde::de::Error::duplicate_field("tags"));
3670 }
3671 tags__ = map_.next_value()?;
3672 }
3673 }
3674 }
3675 Ok(create_connection_request::PrivateLink {
3676 provider: provider__.unwrap_or_default(),
3677 service_name: service_name__.unwrap_or_default(),
3678 tags: tags__,
3679 })
3680 }
3681 }
3682 deserializer.deserialize_struct("ddl_service.CreateConnectionRequest.PrivateLink", FIELDS, GeneratedVisitor)
3683 }
3684}
3685impl serde::Serialize for CreateConnectionResponse {
3686 #[allow(deprecated)]
3687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3688 where
3689 S: serde::Serializer,
3690 {
3691 use serde::ser::SerializeStruct;
3692 let mut len = 0;
3693 if self.version.is_some() {
3694 len += 1;
3695 }
3696 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateConnectionResponse", len)?;
3697 if let Some(v) = self.version.as_ref() {
3698 struct_ser.serialize_field("version", v)?;
3699 }
3700 struct_ser.end()
3701 }
3702}
3703impl<'de> serde::Deserialize<'de> for CreateConnectionResponse {
3704 #[allow(deprecated)]
3705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3706 where
3707 D: serde::Deserializer<'de>,
3708 {
3709 const FIELDS: &[&str] = &[
3710 "version",
3711 ];
3712
3713 #[allow(clippy::enum_variant_names)]
3714 enum GeneratedField {
3715 Version,
3716 }
3717 impl<'de> serde::Deserialize<'de> for GeneratedField {
3718 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3719 where
3720 D: serde::Deserializer<'de>,
3721 {
3722 struct GeneratedVisitor;
3723
3724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3725 type Value = GeneratedField;
3726
3727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3728 write!(formatter, "expected one of: {:?}", &FIELDS)
3729 }
3730
3731 #[allow(unused_variables)]
3732 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3733 where
3734 E: serde::de::Error,
3735 {
3736 match value {
3737 "version" => Ok(GeneratedField::Version),
3738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3739 }
3740 }
3741 }
3742 deserializer.deserialize_identifier(GeneratedVisitor)
3743 }
3744 }
3745 struct GeneratedVisitor;
3746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3747 type Value = CreateConnectionResponse;
3748
3749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3750 formatter.write_str("struct ddl_service.CreateConnectionResponse")
3751 }
3752
3753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateConnectionResponse, V::Error>
3754 where
3755 V: serde::de::MapAccess<'de>,
3756 {
3757 let mut version__ = None;
3758 while let Some(k) = map_.next_key()? {
3759 match k {
3760 GeneratedField::Version => {
3761 if version__.is_some() {
3762 return Err(serde::de::Error::duplicate_field("version"));
3763 }
3764 version__ = map_.next_value()?;
3765 }
3766 }
3767 }
3768 Ok(CreateConnectionResponse {
3769 version: version__,
3770 })
3771 }
3772 }
3773 deserializer.deserialize_struct("ddl_service.CreateConnectionResponse", FIELDS, GeneratedVisitor)
3774 }
3775}
3776impl serde::Serialize for CreateDatabaseRequest {
3777 #[allow(deprecated)]
3778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3779 where
3780 S: serde::Serializer,
3781 {
3782 use serde::ser::SerializeStruct;
3783 let mut len = 0;
3784 if self.db.is_some() {
3785 len += 1;
3786 }
3787 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseRequest", len)?;
3788 if let Some(v) = self.db.as_ref() {
3789 struct_ser.serialize_field("db", v)?;
3790 }
3791 struct_ser.end()
3792 }
3793}
3794impl<'de> serde::Deserialize<'de> for CreateDatabaseRequest {
3795 #[allow(deprecated)]
3796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3797 where
3798 D: serde::Deserializer<'de>,
3799 {
3800 const FIELDS: &[&str] = &[
3801 "db",
3802 ];
3803
3804 #[allow(clippy::enum_variant_names)]
3805 enum GeneratedField {
3806 Db,
3807 }
3808 impl<'de> serde::Deserialize<'de> for GeneratedField {
3809 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3810 where
3811 D: serde::Deserializer<'de>,
3812 {
3813 struct GeneratedVisitor;
3814
3815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3816 type Value = GeneratedField;
3817
3818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3819 write!(formatter, "expected one of: {:?}", &FIELDS)
3820 }
3821
3822 #[allow(unused_variables)]
3823 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3824 where
3825 E: serde::de::Error,
3826 {
3827 match value {
3828 "db" => Ok(GeneratedField::Db),
3829 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3830 }
3831 }
3832 }
3833 deserializer.deserialize_identifier(GeneratedVisitor)
3834 }
3835 }
3836 struct GeneratedVisitor;
3837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3838 type Value = CreateDatabaseRequest;
3839
3840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3841 formatter.write_str("struct ddl_service.CreateDatabaseRequest")
3842 }
3843
3844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseRequest, V::Error>
3845 where
3846 V: serde::de::MapAccess<'de>,
3847 {
3848 let mut db__ = None;
3849 while let Some(k) = map_.next_key()? {
3850 match k {
3851 GeneratedField::Db => {
3852 if db__.is_some() {
3853 return Err(serde::de::Error::duplicate_field("db"));
3854 }
3855 db__ = map_.next_value()?;
3856 }
3857 }
3858 }
3859 Ok(CreateDatabaseRequest {
3860 db: db__,
3861 })
3862 }
3863 }
3864 deserializer.deserialize_struct("ddl_service.CreateDatabaseRequest", FIELDS, GeneratedVisitor)
3865 }
3866}
3867impl serde::Serialize for CreateDatabaseResponse {
3868 #[allow(deprecated)]
3869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3870 where
3871 S: serde::Serializer,
3872 {
3873 use serde::ser::SerializeStruct;
3874 let mut len = 0;
3875 if self.status.is_some() {
3876 len += 1;
3877 }
3878 if self.version.is_some() {
3879 len += 1;
3880 }
3881 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateDatabaseResponse", len)?;
3882 if let Some(v) = self.status.as_ref() {
3883 struct_ser.serialize_field("status", v)?;
3884 }
3885 if let Some(v) = self.version.as_ref() {
3886 struct_ser.serialize_field("version", v)?;
3887 }
3888 struct_ser.end()
3889 }
3890}
3891impl<'de> serde::Deserialize<'de> for CreateDatabaseResponse {
3892 #[allow(deprecated)]
3893 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3894 where
3895 D: serde::Deserializer<'de>,
3896 {
3897 const FIELDS: &[&str] = &[
3898 "status",
3899 "version",
3900 ];
3901
3902 #[allow(clippy::enum_variant_names)]
3903 enum GeneratedField {
3904 Status,
3905 Version,
3906 }
3907 impl<'de> serde::Deserialize<'de> for GeneratedField {
3908 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3909 where
3910 D: serde::Deserializer<'de>,
3911 {
3912 struct GeneratedVisitor;
3913
3914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915 type Value = GeneratedField;
3916
3917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918 write!(formatter, "expected one of: {:?}", &FIELDS)
3919 }
3920
3921 #[allow(unused_variables)]
3922 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3923 where
3924 E: serde::de::Error,
3925 {
3926 match value {
3927 "status" => Ok(GeneratedField::Status),
3928 "version" => Ok(GeneratedField::Version),
3929 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3930 }
3931 }
3932 }
3933 deserializer.deserialize_identifier(GeneratedVisitor)
3934 }
3935 }
3936 struct GeneratedVisitor;
3937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3938 type Value = CreateDatabaseResponse;
3939
3940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3941 formatter.write_str("struct ddl_service.CreateDatabaseResponse")
3942 }
3943
3944 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateDatabaseResponse, V::Error>
3945 where
3946 V: serde::de::MapAccess<'de>,
3947 {
3948 let mut status__ = None;
3949 let mut version__ = None;
3950 while let Some(k) = map_.next_key()? {
3951 match k {
3952 GeneratedField::Status => {
3953 if status__.is_some() {
3954 return Err(serde::de::Error::duplicate_field("status"));
3955 }
3956 status__ = map_.next_value()?;
3957 }
3958 GeneratedField::Version => {
3959 if version__.is_some() {
3960 return Err(serde::de::Error::duplicate_field("version"));
3961 }
3962 version__ = map_.next_value()?;
3963 }
3964 }
3965 }
3966 Ok(CreateDatabaseResponse {
3967 status: status__,
3968 version: version__,
3969 })
3970 }
3971 }
3972 deserializer.deserialize_struct("ddl_service.CreateDatabaseResponse", FIELDS, GeneratedVisitor)
3973 }
3974}
3975impl serde::Serialize for CreateFunctionRequest {
3976 #[allow(deprecated)]
3977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3978 where
3979 S: serde::Serializer,
3980 {
3981 use serde::ser::SerializeStruct;
3982 let mut len = 0;
3983 if self.function.is_some() {
3984 len += 1;
3985 }
3986 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionRequest", len)?;
3987 if let Some(v) = self.function.as_ref() {
3988 struct_ser.serialize_field("function", v)?;
3989 }
3990 struct_ser.end()
3991 }
3992}
3993impl<'de> serde::Deserialize<'de> for CreateFunctionRequest {
3994 #[allow(deprecated)]
3995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3996 where
3997 D: serde::Deserializer<'de>,
3998 {
3999 const FIELDS: &[&str] = &[
4000 "function",
4001 ];
4002
4003 #[allow(clippy::enum_variant_names)]
4004 enum GeneratedField {
4005 Function,
4006 }
4007 impl<'de> serde::Deserialize<'de> for GeneratedField {
4008 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4009 where
4010 D: serde::Deserializer<'de>,
4011 {
4012 struct GeneratedVisitor;
4013
4014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4015 type Value = GeneratedField;
4016
4017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4018 write!(formatter, "expected one of: {:?}", &FIELDS)
4019 }
4020
4021 #[allow(unused_variables)]
4022 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4023 where
4024 E: serde::de::Error,
4025 {
4026 match value {
4027 "function" => Ok(GeneratedField::Function),
4028 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4029 }
4030 }
4031 }
4032 deserializer.deserialize_identifier(GeneratedVisitor)
4033 }
4034 }
4035 struct GeneratedVisitor;
4036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4037 type Value = CreateFunctionRequest;
4038
4039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4040 formatter.write_str("struct ddl_service.CreateFunctionRequest")
4041 }
4042
4043 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionRequest, V::Error>
4044 where
4045 V: serde::de::MapAccess<'de>,
4046 {
4047 let mut function__ = None;
4048 while let Some(k) = map_.next_key()? {
4049 match k {
4050 GeneratedField::Function => {
4051 if function__.is_some() {
4052 return Err(serde::de::Error::duplicate_field("function"));
4053 }
4054 function__ = map_.next_value()?;
4055 }
4056 }
4057 }
4058 Ok(CreateFunctionRequest {
4059 function: function__,
4060 })
4061 }
4062 }
4063 deserializer.deserialize_struct("ddl_service.CreateFunctionRequest", FIELDS, GeneratedVisitor)
4064 }
4065}
4066impl serde::Serialize for CreateFunctionResponse {
4067 #[allow(deprecated)]
4068 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4069 where
4070 S: serde::Serializer,
4071 {
4072 use serde::ser::SerializeStruct;
4073 let mut len = 0;
4074 if self.status.is_some() {
4075 len += 1;
4076 }
4077 if self.version.is_some() {
4078 len += 1;
4079 }
4080 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateFunctionResponse", len)?;
4081 if let Some(v) = self.status.as_ref() {
4082 struct_ser.serialize_field("status", v)?;
4083 }
4084 if let Some(v) = self.version.as_ref() {
4085 struct_ser.serialize_field("version", v)?;
4086 }
4087 struct_ser.end()
4088 }
4089}
4090impl<'de> serde::Deserialize<'de> for CreateFunctionResponse {
4091 #[allow(deprecated)]
4092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4093 where
4094 D: serde::Deserializer<'de>,
4095 {
4096 const FIELDS: &[&str] = &[
4097 "status",
4098 "version",
4099 ];
4100
4101 #[allow(clippy::enum_variant_names)]
4102 enum GeneratedField {
4103 Status,
4104 Version,
4105 }
4106 impl<'de> serde::Deserialize<'de> for GeneratedField {
4107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4108 where
4109 D: serde::Deserializer<'de>,
4110 {
4111 struct GeneratedVisitor;
4112
4113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4114 type Value = GeneratedField;
4115
4116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4117 write!(formatter, "expected one of: {:?}", &FIELDS)
4118 }
4119
4120 #[allow(unused_variables)]
4121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4122 where
4123 E: serde::de::Error,
4124 {
4125 match value {
4126 "status" => Ok(GeneratedField::Status),
4127 "version" => Ok(GeneratedField::Version),
4128 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4129 }
4130 }
4131 }
4132 deserializer.deserialize_identifier(GeneratedVisitor)
4133 }
4134 }
4135 struct GeneratedVisitor;
4136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4137 type Value = CreateFunctionResponse;
4138
4139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4140 formatter.write_str("struct ddl_service.CreateFunctionResponse")
4141 }
4142
4143 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateFunctionResponse, V::Error>
4144 where
4145 V: serde::de::MapAccess<'de>,
4146 {
4147 let mut status__ = None;
4148 let mut version__ = None;
4149 while let Some(k) = map_.next_key()? {
4150 match k {
4151 GeneratedField::Status => {
4152 if status__.is_some() {
4153 return Err(serde::de::Error::duplicate_field("status"));
4154 }
4155 status__ = map_.next_value()?;
4156 }
4157 GeneratedField::Version => {
4158 if version__.is_some() {
4159 return Err(serde::de::Error::duplicate_field("version"));
4160 }
4161 version__ = map_.next_value()?;
4162 }
4163 }
4164 }
4165 Ok(CreateFunctionResponse {
4166 status: status__,
4167 version: version__,
4168 })
4169 }
4170 }
4171 deserializer.deserialize_struct("ddl_service.CreateFunctionResponse", FIELDS, GeneratedVisitor)
4172 }
4173}
4174impl serde::Serialize for CreateIcebergTableRequest {
4175 #[allow(deprecated)]
4176 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4177 where
4178 S: serde::Serializer,
4179 {
4180 use serde::ser::SerializeStruct;
4181 let mut len = 0;
4182 if self.table_info.is_some() {
4183 len += 1;
4184 }
4185 if self.sink_info.is_some() {
4186 len += 1;
4187 }
4188 if self.iceberg_source.is_some() {
4189 len += 1;
4190 }
4191 if self.if_not_exists {
4192 len += 1;
4193 }
4194 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest", len)?;
4195 if let Some(v) = self.table_info.as_ref() {
4196 struct_ser.serialize_field("tableInfo", v)?;
4197 }
4198 if let Some(v) = self.sink_info.as_ref() {
4199 struct_ser.serialize_field("sinkInfo", v)?;
4200 }
4201 if let Some(v) = self.iceberg_source.as_ref() {
4202 struct_ser.serialize_field("icebergSource", v)?;
4203 }
4204 if self.if_not_exists {
4205 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4206 }
4207 struct_ser.end()
4208 }
4209}
4210impl<'de> serde::Deserialize<'de> for CreateIcebergTableRequest {
4211 #[allow(deprecated)]
4212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4213 where
4214 D: serde::Deserializer<'de>,
4215 {
4216 const FIELDS: &[&str] = &[
4217 "table_info",
4218 "tableInfo",
4219 "sink_info",
4220 "sinkInfo",
4221 "iceberg_source",
4222 "icebergSource",
4223 "if_not_exists",
4224 "ifNotExists",
4225 ];
4226
4227 #[allow(clippy::enum_variant_names)]
4228 enum GeneratedField {
4229 TableInfo,
4230 SinkInfo,
4231 IcebergSource,
4232 IfNotExists,
4233 }
4234 impl<'de> serde::Deserialize<'de> for GeneratedField {
4235 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4236 where
4237 D: serde::Deserializer<'de>,
4238 {
4239 struct GeneratedVisitor;
4240
4241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4242 type Value = GeneratedField;
4243
4244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4245 write!(formatter, "expected one of: {:?}", &FIELDS)
4246 }
4247
4248 #[allow(unused_variables)]
4249 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4250 where
4251 E: serde::de::Error,
4252 {
4253 match value {
4254 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
4255 "sinkInfo" | "sink_info" => Ok(GeneratedField::SinkInfo),
4256 "icebergSource" | "iceberg_source" => Ok(GeneratedField::IcebergSource),
4257 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4259 }
4260 }
4261 }
4262 deserializer.deserialize_identifier(GeneratedVisitor)
4263 }
4264 }
4265 struct GeneratedVisitor;
4266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4267 type Value = CreateIcebergTableRequest;
4268
4269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4270 formatter.write_str("struct ddl_service.CreateIcebergTableRequest")
4271 }
4272
4273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableRequest, V::Error>
4274 where
4275 V: serde::de::MapAccess<'de>,
4276 {
4277 let mut table_info__ = None;
4278 let mut sink_info__ = None;
4279 let mut iceberg_source__ = None;
4280 let mut if_not_exists__ = None;
4281 while let Some(k) = map_.next_key()? {
4282 match k {
4283 GeneratedField::TableInfo => {
4284 if table_info__.is_some() {
4285 return Err(serde::de::Error::duplicate_field("tableInfo"));
4286 }
4287 table_info__ = map_.next_value()?;
4288 }
4289 GeneratedField::SinkInfo => {
4290 if sink_info__.is_some() {
4291 return Err(serde::de::Error::duplicate_field("sinkInfo"));
4292 }
4293 sink_info__ = map_.next_value()?;
4294 }
4295 GeneratedField::IcebergSource => {
4296 if iceberg_source__.is_some() {
4297 return Err(serde::de::Error::duplicate_field("icebergSource"));
4298 }
4299 iceberg_source__ = map_.next_value()?;
4300 }
4301 GeneratedField::IfNotExists => {
4302 if if_not_exists__.is_some() {
4303 return Err(serde::de::Error::duplicate_field("ifNotExists"));
4304 }
4305 if_not_exists__ = Some(map_.next_value()?);
4306 }
4307 }
4308 }
4309 Ok(CreateIcebergTableRequest {
4310 table_info: table_info__,
4311 sink_info: sink_info__,
4312 iceberg_source: iceberg_source__,
4313 if_not_exists: if_not_exists__.unwrap_or_default(),
4314 })
4315 }
4316 }
4317 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest", FIELDS, GeneratedVisitor)
4318 }
4319}
4320impl serde::Serialize for create_iceberg_table_request::SinkJobInfo {
4321 #[allow(deprecated)]
4322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4323 where
4324 S: serde::Serializer,
4325 {
4326 use serde::ser::SerializeStruct;
4327 let mut len = 0;
4328 if self.sink.is_some() {
4329 len += 1;
4330 }
4331 if self.fragment_graph.is_some() {
4332 len += 1;
4333 }
4334 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", len)?;
4335 if let Some(v) = self.sink.as_ref() {
4336 struct_ser.serialize_field("sink", v)?;
4337 }
4338 if let Some(v) = self.fragment_graph.as_ref() {
4339 struct_ser.serialize_field("fragmentGraph", v)?;
4340 }
4341 struct_ser.end()
4342 }
4343}
4344impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::SinkJobInfo {
4345 #[allow(deprecated)]
4346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4347 where
4348 D: serde::Deserializer<'de>,
4349 {
4350 const FIELDS: &[&str] = &[
4351 "sink",
4352 "fragment_graph",
4353 "fragmentGraph",
4354 ];
4355
4356 #[allow(clippy::enum_variant_names)]
4357 enum GeneratedField {
4358 Sink,
4359 FragmentGraph,
4360 }
4361 impl<'de> serde::Deserialize<'de> for GeneratedField {
4362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4363 where
4364 D: serde::Deserializer<'de>,
4365 {
4366 struct GeneratedVisitor;
4367
4368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4369 type Value = GeneratedField;
4370
4371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4372 write!(formatter, "expected one of: {:?}", &FIELDS)
4373 }
4374
4375 #[allow(unused_variables)]
4376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4377 where
4378 E: serde::de::Error,
4379 {
4380 match value {
4381 "sink" => Ok(GeneratedField::Sink),
4382 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4384 }
4385 }
4386 }
4387 deserializer.deserialize_identifier(GeneratedVisitor)
4388 }
4389 }
4390 struct GeneratedVisitor;
4391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4392 type Value = create_iceberg_table_request::SinkJobInfo;
4393
4394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4395 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.SinkJobInfo")
4396 }
4397
4398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::SinkJobInfo, V::Error>
4399 where
4400 V: serde::de::MapAccess<'de>,
4401 {
4402 let mut sink__ = None;
4403 let mut fragment_graph__ = None;
4404 while let Some(k) = map_.next_key()? {
4405 match k {
4406 GeneratedField::Sink => {
4407 if sink__.is_some() {
4408 return Err(serde::de::Error::duplicate_field("sink"));
4409 }
4410 sink__ = map_.next_value()?;
4411 }
4412 GeneratedField::FragmentGraph => {
4413 if fragment_graph__.is_some() {
4414 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4415 }
4416 fragment_graph__ = map_.next_value()?;
4417 }
4418 }
4419 }
4420 Ok(create_iceberg_table_request::SinkJobInfo {
4421 sink: sink__,
4422 fragment_graph: fragment_graph__,
4423 })
4424 }
4425 }
4426 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.SinkJobInfo", FIELDS, GeneratedVisitor)
4427 }
4428}
4429impl serde::Serialize for create_iceberg_table_request::TableJobInfo {
4430 #[allow(deprecated)]
4431 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4432 where
4433 S: serde::Serializer,
4434 {
4435 use serde::ser::SerializeStruct;
4436 let mut len = 0;
4437 if self.source.is_some() {
4438 len += 1;
4439 }
4440 if self.table.is_some() {
4441 len += 1;
4442 }
4443 if self.fragment_graph.is_some() {
4444 len += 1;
4445 }
4446 if self.job_type != 0 {
4447 len += 1;
4448 }
4449 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", len)?;
4450 if let Some(v) = self.source.as_ref() {
4451 struct_ser.serialize_field("source", v)?;
4452 }
4453 if let Some(v) = self.table.as_ref() {
4454 struct_ser.serialize_field("table", v)?;
4455 }
4456 if let Some(v) = self.fragment_graph.as_ref() {
4457 struct_ser.serialize_field("fragmentGraph", v)?;
4458 }
4459 if self.job_type != 0 {
4460 let v = TableJobType::try_from(self.job_type)
4461 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
4462 struct_ser.serialize_field("jobType", &v)?;
4463 }
4464 struct_ser.end()
4465 }
4466}
4467impl<'de> serde::Deserialize<'de> for create_iceberg_table_request::TableJobInfo {
4468 #[allow(deprecated)]
4469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4470 where
4471 D: serde::Deserializer<'de>,
4472 {
4473 const FIELDS: &[&str] = &[
4474 "source",
4475 "table",
4476 "fragment_graph",
4477 "fragmentGraph",
4478 "job_type",
4479 "jobType",
4480 ];
4481
4482 #[allow(clippy::enum_variant_names)]
4483 enum GeneratedField {
4484 Source,
4485 Table,
4486 FragmentGraph,
4487 JobType,
4488 }
4489 impl<'de> serde::Deserialize<'de> for GeneratedField {
4490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4491 where
4492 D: serde::Deserializer<'de>,
4493 {
4494 struct GeneratedVisitor;
4495
4496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4497 type Value = GeneratedField;
4498
4499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4500 write!(formatter, "expected one of: {:?}", &FIELDS)
4501 }
4502
4503 #[allow(unused_variables)]
4504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4505 where
4506 E: serde::de::Error,
4507 {
4508 match value {
4509 "source" => Ok(GeneratedField::Source),
4510 "table" => Ok(GeneratedField::Table),
4511 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4512 "jobType" | "job_type" => Ok(GeneratedField::JobType),
4513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4514 }
4515 }
4516 }
4517 deserializer.deserialize_identifier(GeneratedVisitor)
4518 }
4519 }
4520 struct GeneratedVisitor;
4521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4522 type Value = create_iceberg_table_request::TableJobInfo;
4523
4524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4525 formatter.write_str("struct ddl_service.CreateIcebergTableRequest.TableJobInfo")
4526 }
4527
4528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<create_iceberg_table_request::TableJobInfo, V::Error>
4529 where
4530 V: serde::de::MapAccess<'de>,
4531 {
4532 let mut source__ = None;
4533 let mut table__ = None;
4534 let mut fragment_graph__ = None;
4535 let mut job_type__ = None;
4536 while let Some(k) = map_.next_key()? {
4537 match k {
4538 GeneratedField::Source => {
4539 if source__.is_some() {
4540 return Err(serde::de::Error::duplicate_field("source"));
4541 }
4542 source__ = map_.next_value()?;
4543 }
4544 GeneratedField::Table => {
4545 if table__.is_some() {
4546 return Err(serde::de::Error::duplicate_field("table"));
4547 }
4548 table__ = map_.next_value()?;
4549 }
4550 GeneratedField::FragmentGraph => {
4551 if fragment_graph__.is_some() {
4552 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4553 }
4554 fragment_graph__ = map_.next_value()?;
4555 }
4556 GeneratedField::JobType => {
4557 if job_type__.is_some() {
4558 return Err(serde::de::Error::duplicate_field("jobType"));
4559 }
4560 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
4561 }
4562 }
4563 }
4564 Ok(create_iceberg_table_request::TableJobInfo {
4565 source: source__,
4566 table: table__,
4567 fragment_graph: fragment_graph__,
4568 job_type: job_type__.unwrap_or_default(),
4569 })
4570 }
4571 }
4572 deserializer.deserialize_struct("ddl_service.CreateIcebergTableRequest.TableJobInfo", FIELDS, GeneratedVisitor)
4573 }
4574}
4575impl serde::Serialize for CreateIcebergTableResponse {
4576 #[allow(deprecated)]
4577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4578 where
4579 S: serde::Serializer,
4580 {
4581 use serde::ser::SerializeStruct;
4582 let mut len = 0;
4583 if self.status.is_some() {
4584 len += 1;
4585 }
4586 if self.version.is_some() {
4587 len += 1;
4588 }
4589 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIcebergTableResponse", len)?;
4590 if let Some(v) = self.status.as_ref() {
4591 struct_ser.serialize_field("status", v)?;
4592 }
4593 if let Some(v) = self.version.as_ref() {
4594 struct_ser.serialize_field("version", v)?;
4595 }
4596 struct_ser.end()
4597 }
4598}
4599impl<'de> serde::Deserialize<'de> for CreateIcebergTableResponse {
4600 #[allow(deprecated)]
4601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4602 where
4603 D: serde::Deserializer<'de>,
4604 {
4605 const FIELDS: &[&str] = &[
4606 "status",
4607 "version",
4608 ];
4609
4610 #[allow(clippy::enum_variant_names)]
4611 enum GeneratedField {
4612 Status,
4613 Version,
4614 }
4615 impl<'de> serde::Deserialize<'de> for GeneratedField {
4616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4617 where
4618 D: serde::Deserializer<'de>,
4619 {
4620 struct GeneratedVisitor;
4621
4622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4623 type Value = GeneratedField;
4624
4625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4626 write!(formatter, "expected one of: {:?}", &FIELDS)
4627 }
4628
4629 #[allow(unused_variables)]
4630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4631 where
4632 E: serde::de::Error,
4633 {
4634 match value {
4635 "status" => Ok(GeneratedField::Status),
4636 "version" => Ok(GeneratedField::Version),
4637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4638 }
4639 }
4640 }
4641 deserializer.deserialize_identifier(GeneratedVisitor)
4642 }
4643 }
4644 struct GeneratedVisitor;
4645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4646 type Value = CreateIcebergTableResponse;
4647
4648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4649 formatter.write_str("struct ddl_service.CreateIcebergTableResponse")
4650 }
4651
4652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIcebergTableResponse, V::Error>
4653 where
4654 V: serde::de::MapAccess<'de>,
4655 {
4656 let mut status__ = None;
4657 let mut version__ = None;
4658 while let Some(k) = map_.next_key()? {
4659 match k {
4660 GeneratedField::Status => {
4661 if status__.is_some() {
4662 return Err(serde::de::Error::duplicate_field("status"));
4663 }
4664 status__ = map_.next_value()?;
4665 }
4666 GeneratedField::Version => {
4667 if version__.is_some() {
4668 return Err(serde::de::Error::duplicate_field("version"));
4669 }
4670 version__ = map_.next_value()?;
4671 }
4672 }
4673 }
4674 Ok(CreateIcebergTableResponse {
4675 status: status__,
4676 version: version__,
4677 })
4678 }
4679 }
4680 deserializer.deserialize_struct("ddl_service.CreateIcebergTableResponse", FIELDS, GeneratedVisitor)
4681 }
4682}
4683impl serde::Serialize for CreateIndexRequest {
4684 #[allow(deprecated)]
4685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4686 where
4687 S: serde::Serializer,
4688 {
4689 use serde::ser::SerializeStruct;
4690 let mut len = 0;
4691 if self.index.is_some() {
4692 len += 1;
4693 }
4694 if self.index_table.is_some() {
4695 len += 1;
4696 }
4697 if self.fragment_graph.is_some() {
4698 len += 1;
4699 }
4700 if self.if_not_exists {
4701 len += 1;
4702 }
4703 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexRequest", len)?;
4704 if let Some(v) = self.index.as_ref() {
4705 struct_ser.serialize_field("index", v)?;
4706 }
4707 if let Some(v) = self.index_table.as_ref() {
4708 struct_ser.serialize_field("indexTable", v)?;
4709 }
4710 if let Some(v) = self.fragment_graph.as_ref() {
4711 struct_ser.serialize_field("fragmentGraph", v)?;
4712 }
4713 if self.if_not_exists {
4714 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4715 }
4716 struct_ser.end()
4717 }
4718}
4719impl<'de> serde::Deserialize<'de> for CreateIndexRequest {
4720 #[allow(deprecated)]
4721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4722 where
4723 D: serde::Deserializer<'de>,
4724 {
4725 const FIELDS: &[&str] = &[
4726 "index",
4727 "index_table",
4728 "indexTable",
4729 "fragment_graph",
4730 "fragmentGraph",
4731 "if_not_exists",
4732 "ifNotExists",
4733 ];
4734
4735 #[allow(clippy::enum_variant_names)]
4736 enum GeneratedField {
4737 Index,
4738 IndexTable,
4739 FragmentGraph,
4740 IfNotExists,
4741 }
4742 impl<'de> serde::Deserialize<'de> for GeneratedField {
4743 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4744 where
4745 D: serde::Deserializer<'de>,
4746 {
4747 struct GeneratedVisitor;
4748
4749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4750 type Value = GeneratedField;
4751
4752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4753 write!(formatter, "expected one of: {:?}", &FIELDS)
4754 }
4755
4756 #[allow(unused_variables)]
4757 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4758 where
4759 E: serde::de::Error,
4760 {
4761 match value {
4762 "index" => Ok(GeneratedField::Index),
4763 "indexTable" | "index_table" => Ok(GeneratedField::IndexTable),
4764 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
4765 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
4766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4767 }
4768 }
4769 }
4770 deserializer.deserialize_identifier(GeneratedVisitor)
4771 }
4772 }
4773 struct GeneratedVisitor;
4774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4775 type Value = CreateIndexRequest;
4776
4777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4778 formatter.write_str("struct ddl_service.CreateIndexRequest")
4779 }
4780
4781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexRequest, V::Error>
4782 where
4783 V: serde::de::MapAccess<'de>,
4784 {
4785 let mut index__ = None;
4786 let mut index_table__ = None;
4787 let mut fragment_graph__ = None;
4788 let mut if_not_exists__ = None;
4789 while let Some(k) = map_.next_key()? {
4790 match k {
4791 GeneratedField::Index => {
4792 if index__.is_some() {
4793 return Err(serde::de::Error::duplicate_field("index"));
4794 }
4795 index__ = map_.next_value()?;
4796 }
4797 GeneratedField::IndexTable => {
4798 if index_table__.is_some() {
4799 return Err(serde::de::Error::duplicate_field("indexTable"));
4800 }
4801 index_table__ = map_.next_value()?;
4802 }
4803 GeneratedField::FragmentGraph => {
4804 if fragment_graph__.is_some() {
4805 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
4806 }
4807 fragment_graph__ = map_.next_value()?;
4808 }
4809 GeneratedField::IfNotExists => {
4810 if if_not_exists__.is_some() {
4811 return Err(serde::de::Error::duplicate_field("ifNotExists"));
4812 }
4813 if_not_exists__ = Some(map_.next_value()?);
4814 }
4815 }
4816 }
4817 Ok(CreateIndexRequest {
4818 index: index__,
4819 index_table: index_table__,
4820 fragment_graph: fragment_graph__,
4821 if_not_exists: if_not_exists__.unwrap_or_default(),
4822 })
4823 }
4824 }
4825 deserializer.deserialize_struct("ddl_service.CreateIndexRequest", FIELDS, GeneratedVisitor)
4826 }
4827}
4828impl serde::Serialize for CreateIndexResponse {
4829 #[allow(deprecated)]
4830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4831 where
4832 S: serde::Serializer,
4833 {
4834 use serde::ser::SerializeStruct;
4835 let mut len = 0;
4836 if self.status.is_some() {
4837 len += 1;
4838 }
4839 if self.version.is_some() {
4840 len += 1;
4841 }
4842 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateIndexResponse", len)?;
4843 if let Some(v) = self.status.as_ref() {
4844 struct_ser.serialize_field("status", v)?;
4845 }
4846 if let Some(v) = self.version.as_ref() {
4847 struct_ser.serialize_field("version", v)?;
4848 }
4849 struct_ser.end()
4850 }
4851}
4852impl<'de> serde::Deserialize<'de> for CreateIndexResponse {
4853 #[allow(deprecated)]
4854 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4855 where
4856 D: serde::Deserializer<'de>,
4857 {
4858 const FIELDS: &[&str] = &[
4859 "status",
4860 "version",
4861 ];
4862
4863 #[allow(clippy::enum_variant_names)]
4864 enum GeneratedField {
4865 Status,
4866 Version,
4867 }
4868 impl<'de> serde::Deserialize<'de> for GeneratedField {
4869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4870 where
4871 D: serde::Deserializer<'de>,
4872 {
4873 struct GeneratedVisitor;
4874
4875 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4876 type Value = GeneratedField;
4877
4878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4879 write!(formatter, "expected one of: {:?}", &FIELDS)
4880 }
4881
4882 #[allow(unused_variables)]
4883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4884 where
4885 E: serde::de::Error,
4886 {
4887 match value {
4888 "status" => Ok(GeneratedField::Status),
4889 "version" => Ok(GeneratedField::Version),
4890 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4891 }
4892 }
4893 }
4894 deserializer.deserialize_identifier(GeneratedVisitor)
4895 }
4896 }
4897 struct GeneratedVisitor;
4898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4899 type Value = CreateIndexResponse;
4900
4901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4902 formatter.write_str("struct ddl_service.CreateIndexResponse")
4903 }
4904
4905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateIndexResponse, V::Error>
4906 where
4907 V: serde::de::MapAccess<'de>,
4908 {
4909 let mut status__ = None;
4910 let mut version__ = None;
4911 while let Some(k) = map_.next_key()? {
4912 match k {
4913 GeneratedField::Status => {
4914 if status__.is_some() {
4915 return Err(serde::de::Error::duplicate_field("status"));
4916 }
4917 status__ = map_.next_value()?;
4918 }
4919 GeneratedField::Version => {
4920 if version__.is_some() {
4921 return Err(serde::de::Error::duplicate_field("version"));
4922 }
4923 version__ = map_.next_value()?;
4924 }
4925 }
4926 }
4927 Ok(CreateIndexResponse {
4928 status: status__,
4929 version: version__,
4930 })
4931 }
4932 }
4933 deserializer.deserialize_struct("ddl_service.CreateIndexResponse", FIELDS, GeneratedVisitor)
4934 }
4935}
4936impl serde::Serialize for CreateMaterializedViewRequest {
4937 #[allow(deprecated)]
4938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4939 where
4940 S: serde::Serializer,
4941 {
4942 use serde::ser::SerializeStruct;
4943 let mut len = 0;
4944 if self.materialized_view.is_some() {
4945 len += 1;
4946 }
4947 if self.fragment_graph.is_some() {
4948 len += 1;
4949 }
4950 if self.backfill != 0 {
4951 len += 1;
4952 }
4953 if !self.dependencies.is_empty() {
4954 len += 1;
4955 }
4956 if self.specific_resource_group.is_some() {
4957 len += 1;
4958 }
4959 if self.if_not_exists {
4960 len += 1;
4961 }
4962 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewRequest", len)?;
4963 if let Some(v) = self.materialized_view.as_ref() {
4964 struct_ser.serialize_field("materializedView", v)?;
4965 }
4966 if let Some(v) = self.fragment_graph.as_ref() {
4967 struct_ser.serialize_field("fragmentGraph", v)?;
4968 }
4969 if self.backfill != 0 {
4970 let v = create_materialized_view_request::BackfillType::try_from(self.backfill)
4971 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backfill)))?;
4972 struct_ser.serialize_field("backfill", &v)?;
4973 }
4974 if !self.dependencies.is_empty() {
4975 struct_ser.serialize_field("dependencies", &self.dependencies)?;
4976 }
4977 if let Some(v) = self.specific_resource_group.as_ref() {
4978 struct_ser.serialize_field("specificResourceGroup", v)?;
4979 }
4980 if self.if_not_exists {
4981 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
4982 }
4983 struct_ser.end()
4984 }
4985}
4986impl<'de> serde::Deserialize<'de> for CreateMaterializedViewRequest {
4987 #[allow(deprecated)]
4988 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4989 where
4990 D: serde::Deserializer<'de>,
4991 {
4992 const FIELDS: &[&str] = &[
4993 "materialized_view",
4994 "materializedView",
4995 "fragment_graph",
4996 "fragmentGraph",
4997 "backfill",
4998 "dependencies",
4999 "specific_resource_group",
5000 "specificResourceGroup",
5001 "if_not_exists",
5002 "ifNotExists",
5003 ];
5004
5005 #[allow(clippy::enum_variant_names)]
5006 enum GeneratedField {
5007 MaterializedView,
5008 FragmentGraph,
5009 Backfill,
5010 Dependencies,
5011 SpecificResourceGroup,
5012 IfNotExists,
5013 }
5014 impl<'de> serde::Deserialize<'de> for GeneratedField {
5015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5016 where
5017 D: serde::Deserializer<'de>,
5018 {
5019 struct GeneratedVisitor;
5020
5021 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5022 type Value = GeneratedField;
5023
5024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5025 write!(formatter, "expected one of: {:?}", &FIELDS)
5026 }
5027
5028 #[allow(unused_variables)]
5029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5030 where
5031 E: serde::de::Error,
5032 {
5033 match value {
5034 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5035 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5036 "backfill" => Ok(GeneratedField::Backfill),
5037 "dependencies" => Ok(GeneratedField::Dependencies),
5038 "specificResourceGroup" | "specific_resource_group" => Ok(GeneratedField::SpecificResourceGroup),
5039 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5040 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5041 }
5042 }
5043 }
5044 deserializer.deserialize_identifier(GeneratedVisitor)
5045 }
5046 }
5047 struct GeneratedVisitor;
5048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5049 type Value = CreateMaterializedViewRequest;
5050
5051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5052 formatter.write_str("struct ddl_service.CreateMaterializedViewRequest")
5053 }
5054
5055 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewRequest, V::Error>
5056 where
5057 V: serde::de::MapAccess<'de>,
5058 {
5059 let mut materialized_view__ = None;
5060 let mut fragment_graph__ = None;
5061 let mut backfill__ = None;
5062 let mut dependencies__ = None;
5063 let mut specific_resource_group__ = None;
5064 let mut if_not_exists__ = None;
5065 while let Some(k) = map_.next_key()? {
5066 match k {
5067 GeneratedField::MaterializedView => {
5068 if materialized_view__.is_some() {
5069 return Err(serde::de::Error::duplicate_field("materializedView"));
5070 }
5071 materialized_view__ = map_.next_value()?;
5072 }
5073 GeneratedField::FragmentGraph => {
5074 if fragment_graph__.is_some() {
5075 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5076 }
5077 fragment_graph__ = map_.next_value()?;
5078 }
5079 GeneratedField::Backfill => {
5080 if backfill__.is_some() {
5081 return Err(serde::de::Error::duplicate_field("backfill"));
5082 }
5083 backfill__ = Some(map_.next_value::<create_materialized_view_request::BackfillType>()? as i32);
5084 }
5085 GeneratedField::Dependencies => {
5086 if dependencies__.is_some() {
5087 return Err(serde::de::Error::duplicate_field("dependencies"));
5088 }
5089 dependencies__ =
5090 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5091 .into_iter().map(|x| x.0).collect())
5092 ;
5093 }
5094 GeneratedField::SpecificResourceGroup => {
5095 if specific_resource_group__.is_some() {
5096 return Err(serde::de::Error::duplicate_field("specificResourceGroup"));
5097 }
5098 specific_resource_group__ = map_.next_value()?;
5099 }
5100 GeneratedField::IfNotExists => {
5101 if if_not_exists__.is_some() {
5102 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5103 }
5104 if_not_exists__ = Some(map_.next_value()?);
5105 }
5106 }
5107 }
5108 Ok(CreateMaterializedViewRequest {
5109 materialized_view: materialized_view__,
5110 fragment_graph: fragment_graph__,
5111 backfill: backfill__.unwrap_or_default(),
5112 dependencies: dependencies__.unwrap_or_default(),
5113 specific_resource_group: specific_resource_group__,
5114 if_not_exists: if_not_exists__.unwrap_or_default(),
5115 })
5116 }
5117 }
5118 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewRequest", FIELDS, GeneratedVisitor)
5119 }
5120}
5121impl serde::Serialize for create_materialized_view_request::BackfillType {
5122 #[allow(deprecated)]
5123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5124 where
5125 S: serde::Serializer,
5126 {
5127 let variant = match self {
5128 Self::Unspecified => "UNSPECIFIED",
5129 Self::Regular => "REGULAR",
5130 Self::Serverless => "SERVERLESS",
5131 };
5132 serializer.serialize_str(variant)
5133 }
5134}
5135impl<'de> serde::Deserialize<'de> for create_materialized_view_request::BackfillType {
5136 #[allow(deprecated)]
5137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5138 where
5139 D: serde::Deserializer<'de>,
5140 {
5141 const FIELDS: &[&str] = &[
5142 "UNSPECIFIED",
5143 "REGULAR",
5144 "SERVERLESS",
5145 ];
5146
5147 struct GeneratedVisitor;
5148
5149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5150 type Value = create_materialized_view_request::BackfillType;
5151
5152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5153 write!(formatter, "expected one of: {:?}", &FIELDS)
5154 }
5155
5156 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5157 where
5158 E: serde::de::Error,
5159 {
5160 i32::try_from(v)
5161 .ok()
5162 .and_then(|x| x.try_into().ok())
5163 .ok_or_else(|| {
5164 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5165 })
5166 }
5167
5168 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5169 where
5170 E: serde::de::Error,
5171 {
5172 i32::try_from(v)
5173 .ok()
5174 .and_then(|x| x.try_into().ok())
5175 .ok_or_else(|| {
5176 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5177 })
5178 }
5179
5180 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5181 where
5182 E: serde::de::Error,
5183 {
5184 match value {
5185 "UNSPECIFIED" => Ok(create_materialized_view_request::BackfillType::Unspecified),
5186 "REGULAR" => Ok(create_materialized_view_request::BackfillType::Regular),
5187 "SERVERLESS" => Ok(create_materialized_view_request::BackfillType::Serverless),
5188 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5189 }
5190 }
5191 }
5192 deserializer.deserialize_any(GeneratedVisitor)
5193 }
5194}
5195impl serde::Serialize for CreateMaterializedViewResponse {
5196 #[allow(deprecated)]
5197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5198 where
5199 S: serde::Serializer,
5200 {
5201 use serde::ser::SerializeStruct;
5202 let mut len = 0;
5203 if self.status.is_some() {
5204 len += 1;
5205 }
5206 if self.version.is_some() {
5207 len += 1;
5208 }
5209 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateMaterializedViewResponse", len)?;
5210 if let Some(v) = self.status.as_ref() {
5211 struct_ser.serialize_field("status", v)?;
5212 }
5213 if let Some(v) = self.version.as_ref() {
5214 struct_ser.serialize_field("version", v)?;
5215 }
5216 struct_ser.end()
5217 }
5218}
5219impl<'de> serde::Deserialize<'de> for CreateMaterializedViewResponse {
5220 #[allow(deprecated)]
5221 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5222 where
5223 D: serde::Deserializer<'de>,
5224 {
5225 const FIELDS: &[&str] = &[
5226 "status",
5227 "version",
5228 ];
5229
5230 #[allow(clippy::enum_variant_names)]
5231 enum GeneratedField {
5232 Status,
5233 Version,
5234 }
5235 impl<'de> serde::Deserialize<'de> for GeneratedField {
5236 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5237 where
5238 D: serde::Deserializer<'de>,
5239 {
5240 struct GeneratedVisitor;
5241
5242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5243 type Value = GeneratedField;
5244
5245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5246 write!(formatter, "expected one of: {:?}", &FIELDS)
5247 }
5248
5249 #[allow(unused_variables)]
5250 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5251 where
5252 E: serde::de::Error,
5253 {
5254 match value {
5255 "status" => Ok(GeneratedField::Status),
5256 "version" => Ok(GeneratedField::Version),
5257 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5258 }
5259 }
5260 }
5261 deserializer.deserialize_identifier(GeneratedVisitor)
5262 }
5263 }
5264 struct GeneratedVisitor;
5265 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5266 type Value = CreateMaterializedViewResponse;
5267
5268 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5269 formatter.write_str("struct ddl_service.CreateMaterializedViewResponse")
5270 }
5271
5272 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMaterializedViewResponse, V::Error>
5273 where
5274 V: serde::de::MapAccess<'de>,
5275 {
5276 let mut status__ = None;
5277 let mut version__ = None;
5278 while let Some(k) = map_.next_key()? {
5279 match k {
5280 GeneratedField::Status => {
5281 if status__.is_some() {
5282 return Err(serde::de::Error::duplicate_field("status"));
5283 }
5284 status__ = map_.next_value()?;
5285 }
5286 GeneratedField::Version => {
5287 if version__.is_some() {
5288 return Err(serde::de::Error::duplicate_field("version"));
5289 }
5290 version__ = map_.next_value()?;
5291 }
5292 }
5293 }
5294 Ok(CreateMaterializedViewResponse {
5295 status: status__,
5296 version: version__,
5297 })
5298 }
5299 }
5300 deserializer.deserialize_struct("ddl_service.CreateMaterializedViewResponse", FIELDS, GeneratedVisitor)
5301 }
5302}
5303impl serde::Serialize for CreateSchemaRequest {
5304 #[allow(deprecated)]
5305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5306 where
5307 S: serde::Serializer,
5308 {
5309 use serde::ser::SerializeStruct;
5310 let mut len = 0;
5311 if self.schema.is_some() {
5312 len += 1;
5313 }
5314 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaRequest", len)?;
5315 if let Some(v) = self.schema.as_ref() {
5316 struct_ser.serialize_field("schema", v)?;
5317 }
5318 struct_ser.end()
5319 }
5320}
5321impl<'de> serde::Deserialize<'de> for CreateSchemaRequest {
5322 #[allow(deprecated)]
5323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5324 where
5325 D: serde::Deserializer<'de>,
5326 {
5327 const FIELDS: &[&str] = &[
5328 "schema",
5329 ];
5330
5331 #[allow(clippy::enum_variant_names)]
5332 enum GeneratedField {
5333 Schema,
5334 }
5335 impl<'de> serde::Deserialize<'de> for GeneratedField {
5336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5337 where
5338 D: serde::Deserializer<'de>,
5339 {
5340 struct GeneratedVisitor;
5341
5342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5343 type Value = GeneratedField;
5344
5345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5346 write!(formatter, "expected one of: {:?}", &FIELDS)
5347 }
5348
5349 #[allow(unused_variables)]
5350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5351 where
5352 E: serde::de::Error,
5353 {
5354 match value {
5355 "schema" => Ok(GeneratedField::Schema),
5356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5357 }
5358 }
5359 }
5360 deserializer.deserialize_identifier(GeneratedVisitor)
5361 }
5362 }
5363 struct GeneratedVisitor;
5364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5365 type Value = CreateSchemaRequest;
5366
5367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5368 formatter.write_str("struct ddl_service.CreateSchemaRequest")
5369 }
5370
5371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaRequest, V::Error>
5372 where
5373 V: serde::de::MapAccess<'de>,
5374 {
5375 let mut schema__ = None;
5376 while let Some(k) = map_.next_key()? {
5377 match k {
5378 GeneratedField::Schema => {
5379 if schema__.is_some() {
5380 return Err(serde::de::Error::duplicate_field("schema"));
5381 }
5382 schema__ = map_.next_value()?;
5383 }
5384 }
5385 }
5386 Ok(CreateSchemaRequest {
5387 schema: schema__,
5388 })
5389 }
5390 }
5391 deserializer.deserialize_struct("ddl_service.CreateSchemaRequest", FIELDS, GeneratedVisitor)
5392 }
5393}
5394impl serde::Serialize for CreateSchemaResponse {
5395 #[allow(deprecated)]
5396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5397 where
5398 S: serde::Serializer,
5399 {
5400 use serde::ser::SerializeStruct;
5401 let mut len = 0;
5402 if self.status.is_some() {
5403 len += 1;
5404 }
5405 if self.version.is_some() {
5406 len += 1;
5407 }
5408 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSchemaResponse", len)?;
5409 if let Some(v) = self.status.as_ref() {
5410 struct_ser.serialize_field("status", v)?;
5411 }
5412 if let Some(v) = self.version.as_ref() {
5413 struct_ser.serialize_field("version", v)?;
5414 }
5415 struct_ser.end()
5416 }
5417}
5418impl<'de> serde::Deserialize<'de> for CreateSchemaResponse {
5419 #[allow(deprecated)]
5420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5421 where
5422 D: serde::Deserializer<'de>,
5423 {
5424 const FIELDS: &[&str] = &[
5425 "status",
5426 "version",
5427 ];
5428
5429 #[allow(clippy::enum_variant_names)]
5430 enum GeneratedField {
5431 Status,
5432 Version,
5433 }
5434 impl<'de> serde::Deserialize<'de> for GeneratedField {
5435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5436 where
5437 D: serde::Deserializer<'de>,
5438 {
5439 struct GeneratedVisitor;
5440
5441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5442 type Value = GeneratedField;
5443
5444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5445 write!(formatter, "expected one of: {:?}", &FIELDS)
5446 }
5447
5448 #[allow(unused_variables)]
5449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5450 where
5451 E: serde::de::Error,
5452 {
5453 match value {
5454 "status" => Ok(GeneratedField::Status),
5455 "version" => Ok(GeneratedField::Version),
5456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5457 }
5458 }
5459 }
5460 deserializer.deserialize_identifier(GeneratedVisitor)
5461 }
5462 }
5463 struct GeneratedVisitor;
5464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5465 type Value = CreateSchemaResponse;
5466
5467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5468 formatter.write_str("struct ddl_service.CreateSchemaResponse")
5469 }
5470
5471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSchemaResponse, V::Error>
5472 where
5473 V: serde::de::MapAccess<'de>,
5474 {
5475 let mut status__ = None;
5476 let mut version__ = None;
5477 while let Some(k) = map_.next_key()? {
5478 match k {
5479 GeneratedField::Status => {
5480 if status__.is_some() {
5481 return Err(serde::de::Error::duplicate_field("status"));
5482 }
5483 status__ = map_.next_value()?;
5484 }
5485 GeneratedField::Version => {
5486 if version__.is_some() {
5487 return Err(serde::de::Error::duplicate_field("version"));
5488 }
5489 version__ = map_.next_value()?;
5490 }
5491 }
5492 }
5493 Ok(CreateSchemaResponse {
5494 status: status__,
5495 version: version__,
5496 })
5497 }
5498 }
5499 deserializer.deserialize_struct("ddl_service.CreateSchemaResponse", FIELDS, GeneratedVisitor)
5500 }
5501}
5502impl serde::Serialize for CreateSecretRequest {
5503 #[allow(deprecated)]
5504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5505 where
5506 S: serde::Serializer,
5507 {
5508 use serde::ser::SerializeStruct;
5509 let mut len = 0;
5510 if !self.name.is_empty() {
5511 len += 1;
5512 }
5513 if !self.value.is_empty() {
5514 len += 1;
5515 }
5516 if self.database_id != 0 {
5517 len += 1;
5518 }
5519 if self.schema_id != 0 {
5520 len += 1;
5521 }
5522 if self.owner_id != 0 {
5523 len += 1;
5524 }
5525 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretRequest", len)?;
5526 if !self.name.is_empty() {
5527 struct_ser.serialize_field("name", &self.name)?;
5528 }
5529 if !self.value.is_empty() {
5530 #[allow(clippy::needless_borrow)]
5531 #[allow(clippy::needless_borrows_for_generic_args)]
5532 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
5533 }
5534 if self.database_id != 0 {
5535 struct_ser.serialize_field("databaseId", &self.database_id)?;
5536 }
5537 if self.schema_id != 0 {
5538 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5539 }
5540 if self.owner_id != 0 {
5541 struct_ser.serialize_field("ownerId", &self.owner_id)?;
5542 }
5543 struct_ser.end()
5544 }
5545}
5546impl<'de> serde::Deserialize<'de> for CreateSecretRequest {
5547 #[allow(deprecated)]
5548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5549 where
5550 D: serde::Deserializer<'de>,
5551 {
5552 const FIELDS: &[&str] = &[
5553 "name",
5554 "value",
5555 "database_id",
5556 "databaseId",
5557 "schema_id",
5558 "schemaId",
5559 "owner_id",
5560 "ownerId",
5561 ];
5562
5563 #[allow(clippy::enum_variant_names)]
5564 enum GeneratedField {
5565 Name,
5566 Value,
5567 DatabaseId,
5568 SchemaId,
5569 OwnerId,
5570 }
5571 impl<'de> serde::Deserialize<'de> for GeneratedField {
5572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5573 where
5574 D: serde::Deserializer<'de>,
5575 {
5576 struct GeneratedVisitor;
5577
5578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5579 type Value = GeneratedField;
5580
5581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5582 write!(formatter, "expected one of: {:?}", &FIELDS)
5583 }
5584
5585 #[allow(unused_variables)]
5586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5587 where
5588 E: serde::de::Error,
5589 {
5590 match value {
5591 "name" => Ok(GeneratedField::Name),
5592 "value" => Ok(GeneratedField::Value),
5593 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5594 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5595 "ownerId" | "owner_id" => Ok(GeneratedField::OwnerId),
5596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5597 }
5598 }
5599 }
5600 deserializer.deserialize_identifier(GeneratedVisitor)
5601 }
5602 }
5603 struct GeneratedVisitor;
5604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5605 type Value = CreateSecretRequest;
5606
5607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5608 formatter.write_str("struct ddl_service.CreateSecretRequest")
5609 }
5610
5611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretRequest, V::Error>
5612 where
5613 V: serde::de::MapAccess<'de>,
5614 {
5615 let mut name__ = None;
5616 let mut value__ = None;
5617 let mut database_id__ = None;
5618 let mut schema_id__ = None;
5619 let mut owner_id__ = None;
5620 while let Some(k) = map_.next_key()? {
5621 match k {
5622 GeneratedField::Name => {
5623 if name__.is_some() {
5624 return Err(serde::de::Error::duplicate_field("name"));
5625 }
5626 name__ = Some(map_.next_value()?);
5627 }
5628 GeneratedField::Value => {
5629 if value__.is_some() {
5630 return Err(serde::de::Error::duplicate_field("value"));
5631 }
5632 value__ =
5633 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
5634 ;
5635 }
5636 GeneratedField::DatabaseId => {
5637 if database_id__.is_some() {
5638 return Err(serde::de::Error::duplicate_field("databaseId"));
5639 }
5640 database_id__ =
5641 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5642 ;
5643 }
5644 GeneratedField::SchemaId => {
5645 if schema_id__.is_some() {
5646 return Err(serde::de::Error::duplicate_field("schemaId"));
5647 }
5648 schema_id__ =
5649 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5650 ;
5651 }
5652 GeneratedField::OwnerId => {
5653 if owner_id__.is_some() {
5654 return Err(serde::de::Error::duplicate_field("ownerId"));
5655 }
5656 owner_id__ =
5657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5658 ;
5659 }
5660 }
5661 }
5662 Ok(CreateSecretRequest {
5663 name: name__.unwrap_or_default(),
5664 value: value__.unwrap_or_default(),
5665 database_id: database_id__.unwrap_or_default(),
5666 schema_id: schema_id__.unwrap_or_default(),
5667 owner_id: owner_id__.unwrap_or_default(),
5668 })
5669 }
5670 }
5671 deserializer.deserialize_struct("ddl_service.CreateSecretRequest", FIELDS, GeneratedVisitor)
5672 }
5673}
5674impl serde::Serialize for CreateSecretResponse {
5675 #[allow(deprecated)]
5676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5677 where
5678 S: serde::Serializer,
5679 {
5680 use serde::ser::SerializeStruct;
5681 let mut len = 0;
5682 if self.version.is_some() {
5683 len += 1;
5684 }
5685 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSecretResponse", len)?;
5686 if let Some(v) = self.version.as_ref() {
5687 struct_ser.serialize_field("version", v)?;
5688 }
5689 struct_ser.end()
5690 }
5691}
5692impl<'de> serde::Deserialize<'de> for CreateSecretResponse {
5693 #[allow(deprecated)]
5694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5695 where
5696 D: serde::Deserializer<'de>,
5697 {
5698 const FIELDS: &[&str] = &[
5699 "version",
5700 ];
5701
5702 #[allow(clippy::enum_variant_names)]
5703 enum GeneratedField {
5704 Version,
5705 }
5706 impl<'de> serde::Deserialize<'de> for GeneratedField {
5707 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5708 where
5709 D: serde::Deserializer<'de>,
5710 {
5711 struct GeneratedVisitor;
5712
5713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5714 type Value = GeneratedField;
5715
5716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5717 write!(formatter, "expected one of: {:?}", &FIELDS)
5718 }
5719
5720 #[allow(unused_variables)]
5721 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5722 where
5723 E: serde::de::Error,
5724 {
5725 match value {
5726 "version" => Ok(GeneratedField::Version),
5727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5728 }
5729 }
5730 }
5731 deserializer.deserialize_identifier(GeneratedVisitor)
5732 }
5733 }
5734 struct GeneratedVisitor;
5735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5736 type Value = CreateSecretResponse;
5737
5738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5739 formatter.write_str("struct ddl_service.CreateSecretResponse")
5740 }
5741
5742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSecretResponse, V::Error>
5743 where
5744 V: serde::de::MapAccess<'de>,
5745 {
5746 let mut version__ = None;
5747 while let Some(k) = map_.next_key()? {
5748 match k {
5749 GeneratedField::Version => {
5750 if version__.is_some() {
5751 return Err(serde::de::Error::duplicate_field("version"));
5752 }
5753 version__ = map_.next_value()?;
5754 }
5755 }
5756 }
5757 Ok(CreateSecretResponse {
5758 version: version__,
5759 })
5760 }
5761 }
5762 deserializer.deserialize_struct("ddl_service.CreateSecretResponse", FIELDS, GeneratedVisitor)
5763 }
5764}
5765impl serde::Serialize for CreateSinkRequest {
5766 #[allow(deprecated)]
5767 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5768 where
5769 S: serde::Serializer,
5770 {
5771 use serde::ser::SerializeStruct;
5772 let mut len = 0;
5773 if self.sink.is_some() {
5774 len += 1;
5775 }
5776 if self.fragment_graph.is_some() {
5777 len += 1;
5778 }
5779 if !self.dependencies.is_empty() {
5780 len += 1;
5781 }
5782 if self.if_not_exists {
5783 len += 1;
5784 }
5785 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
5786 if let Some(v) = self.sink.as_ref() {
5787 struct_ser.serialize_field("sink", v)?;
5788 }
5789 if let Some(v) = self.fragment_graph.as_ref() {
5790 struct_ser.serialize_field("fragmentGraph", v)?;
5791 }
5792 if !self.dependencies.is_empty() {
5793 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5794 }
5795 if self.if_not_exists {
5796 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5797 }
5798 struct_ser.end()
5799 }
5800}
5801impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
5802 #[allow(deprecated)]
5803 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5804 where
5805 D: serde::Deserializer<'de>,
5806 {
5807 const FIELDS: &[&str] = &[
5808 "sink",
5809 "fragment_graph",
5810 "fragmentGraph",
5811 "dependencies",
5812 "if_not_exists",
5813 "ifNotExists",
5814 ];
5815
5816 #[allow(clippy::enum_variant_names)]
5817 enum GeneratedField {
5818 Sink,
5819 FragmentGraph,
5820 Dependencies,
5821 IfNotExists,
5822 }
5823 impl<'de> serde::Deserialize<'de> for GeneratedField {
5824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5825 where
5826 D: serde::Deserializer<'de>,
5827 {
5828 struct GeneratedVisitor;
5829
5830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5831 type Value = GeneratedField;
5832
5833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5834 write!(formatter, "expected one of: {:?}", &FIELDS)
5835 }
5836
5837 #[allow(unused_variables)]
5838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5839 where
5840 E: serde::de::Error,
5841 {
5842 match value {
5843 "sink" => Ok(GeneratedField::Sink),
5844 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5845 "dependencies" => Ok(GeneratedField::Dependencies),
5846 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5848 }
5849 }
5850 }
5851 deserializer.deserialize_identifier(GeneratedVisitor)
5852 }
5853 }
5854 struct GeneratedVisitor;
5855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5856 type Value = CreateSinkRequest;
5857
5858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5859 formatter.write_str("struct ddl_service.CreateSinkRequest")
5860 }
5861
5862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
5863 where
5864 V: serde::de::MapAccess<'de>,
5865 {
5866 let mut sink__ = None;
5867 let mut fragment_graph__ = None;
5868 let mut dependencies__ = None;
5869 let mut if_not_exists__ = None;
5870 while let Some(k) = map_.next_key()? {
5871 match k {
5872 GeneratedField::Sink => {
5873 if sink__.is_some() {
5874 return Err(serde::de::Error::duplicate_field("sink"));
5875 }
5876 sink__ = map_.next_value()?;
5877 }
5878 GeneratedField::FragmentGraph => {
5879 if fragment_graph__.is_some() {
5880 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5881 }
5882 fragment_graph__ = map_.next_value()?;
5883 }
5884 GeneratedField::Dependencies => {
5885 if dependencies__.is_some() {
5886 return Err(serde::de::Error::duplicate_field("dependencies"));
5887 }
5888 dependencies__ =
5889 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5890 .into_iter().map(|x| x.0).collect())
5891 ;
5892 }
5893 GeneratedField::IfNotExists => {
5894 if if_not_exists__.is_some() {
5895 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5896 }
5897 if_not_exists__ = Some(map_.next_value()?);
5898 }
5899 }
5900 }
5901 Ok(CreateSinkRequest {
5902 sink: sink__,
5903 fragment_graph: fragment_graph__,
5904 dependencies: dependencies__.unwrap_or_default(),
5905 if_not_exists: if_not_exists__.unwrap_or_default(),
5906 })
5907 }
5908 }
5909 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
5910 }
5911}
5912impl serde::Serialize for CreateSinkResponse {
5913 #[allow(deprecated)]
5914 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5915 where
5916 S: serde::Serializer,
5917 {
5918 use serde::ser::SerializeStruct;
5919 let mut len = 0;
5920 if self.status.is_some() {
5921 len += 1;
5922 }
5923 if self.version.is_some() {
5924 len += 1;
5925 }
5926 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
5927 if let Some(v) = self.status.as_ref() {
5928 struct_ser.serialize_field("status", v)?;
5929 }
5930 if let Some(v) = self.version.as_ref() {
5931 struct_ser.serialize_field("version", v)?;
5932 }
5933 struct_ser.end()
5934 }
5935}
5936impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
5937 #[allow(deprecated)]
5938 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5939 where
5940 D: serde::Deserializer<'de>,
5941 {
5942 const FIELDS: &[&str] = &[
5943 "status",
5944 "version",
5945 ];
5946
5947 #[allow(clippy::enum_variant_names)]
5948 enum GeneratedField {
5949 Status,
5950 Version,
5951 }
5952 impl<'de> serde::Deserialize<'de> for GeneratedField {
5953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5954 where
5955 D: serde::Deserializer<'de>,
5956 {
5957 struct GeneratedVisitor;
5958
5959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5960 type Value = GeneratedField;
5961
5962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5963 write!(formatter, "expected one of: {:?}", &FIELDS)
5964 }
5965
5966 #[allow(unused_variables)]
5967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5968 where
5969 E: serde::de::Error,
5970 {
5971 match value {
5972 "status" => Ok(GeneratedField::Status),
5973 "version" => Ok(GeneratedField::Version),
5974 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5975 }
5976 }
5977 }
5978 deserializer.deserialize_identifier(GeneratedVisitor)
5979 }
5980 }
5981 struct GeneratedVisitor;
5982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5983 type Value = CreateSinkResponse;
5984
5985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5986 formatter.write_str("struct ddl_service.CreateSinkResponse")
5987 }
5988
5989 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
5990 where
5991 V: serde::de::MapAccess<'de>,
5992 {
5993 let mut status__ = None;
5994 let mut version__ = None;
5995 while let Some(k) = map_.next_key()? {
5996 match k {
5997 GeneratedField::Status => {
5998 if status__.is_some() {
5999 return Err(serde::de::Error::duplicate_field("status"));
6000 }
6001 status__ = map_.next_value()?;
6002 }
6003 GeneratedField::Version => {
6004 if version__.is_some() {
6005 return Err(serde::de::Error::duplicate_field("version"));
6006 }
6007 version__ = map_.next_value()?;
6008 }
6009 }
6010 }
6011 Ok(CreateSinkResponse {
6012 status: status__,
6013 version: version__,
6014 })
6015 }
6016 }
6017 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
6018 }
6019}
6020impl serde::Serialize for CreateSourceRequest {
6021 #[allow(deprecated)]
6022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6023 where
6024 S: serde::Serializer,
6025 {
6026 use serde::ser::SerializeStruct;
6027 let mut len = 0;
6028 if self.source.is_some() {
6029 len += 1;
6030 }
6031 if self.fragment_graph.is_some() {
6032 len += 1;
6033 }
6034 if self.if_not_exists {
6035 len += 1;
6036 }
6037 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
6038 if let Some(v) = self.source.as_ref() {
6039 struct_ser.serialize_field("source", v)?;
6040 }
6041 if let Some(v) = self.fragment_graph.as_ref() {
6042 struct_ser.serialize_field("fragmentGraph", v)?;
6043 }
6044 if self.if_not_exists {
6045 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6046 }
6047 struct_ser.end()
6048 }
6049}
6050impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
6051 #[allow(deprecated)]
6052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6053 where
6054 D: serde::Deserializer<'de>,
6055 {
6056 const FIELDS: &[&str] = &[
6057 "source",
6058 "fragment_graph",
6059 "fragmentGraph",
6060 "if_not_exists",
6061 "ifNotExists",
6062 ];
6063
6064 #[allow(clippy::enum_variant_names)]
6065 enum GeneratedField {
6066 Source,
6067 FragmentGraph,
6068 IfNotExists,
6069 }
6070 impl<'de> serde::Deserialize<'de> for GeneratedField {
6071 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6072 where
6073 D: serde::Deserializer<'de>,
6074 {
6075 struct GeneratedVisitor;
6076
6077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6078 type Value = GeneratedField;
6079
6080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6081 write!(formatter, "expected one of: {:?}", &FIELDS)
6082 }
6083
6084 #[allow(unused_variables)]
6085 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6086 where
6087 E: serde::de::Error,
6088 {
6089 match value {
6090 "source" => Ok(GeneratedField::Source),
6091 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6092 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6093 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6094 }
6095 }
6096 }
6097 deserializer.deserialize_identifier(GeneratedVisitor)
6098 }
6099 }
6100 struct GeneratedVisitor;
6101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6102 type Value = CreateSourceRequest;
6103
6104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6105 formatter.write_str("struct ddl_service.CreateSourceRequest")
6106 }
6107
6108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
6109 where
6110 V: serde::de::MapAccess<'de>,
6111 {
6112 let mut source__ = None;
6113 let mut fragment_graph__ = None;
6114 let mut if_not_exists__ = None;
6115 while let Some(k) = map_.next_key()? {
6116 match k {
6117 GeneratedField::Source => {
6118 if source__.is_some() {
6119 return Err(serde::de::Error::duplicate_field("source"));
6120 }
6121 source__ = map_.next_value()?;
6122 }
6123 GeneratedField::FragmentGraph => {
6124 if fragment_graph__.is_some() {
6125 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6126 }
6127 fragment_graph__ = map_.next_value()?;
6128 }
6129 GeneratedField::IfNotExists => {
6130 if if_not_exists__.is_some() {
6131 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6132 }
6133 if_not_exists__ = Some(map_.next_value()?);
6134 }
6135 }
6136 }
6137 Ok(CreateSourceRequest {
6138 source: source__,
6139 fragment_graph: fragment_graph__,
6140 if_not_exists: if_not_exists__.unwrap_or_default(),
6141 })
6142 }
6143 }
6144 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
6145 }
6146}
6147impl serde::Serialize for CreateSourceResponse {
6148 #[allow(deprecated)]
6149 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6150 where
6151 S: serde::Serializer,
6152 {
6153 use serde::ser::SerializeStruct;
6154 let mut len = 0;
6155 if self.status.is_some() {
6156 len += 1;
6157 }
6158 if self.version.is_some() {
6159 len += 1;
6160 }
6161 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
6162 if let Some(v) = self.status.as_ref() {
6163 struct_ser.serialize_field("status", v)?;
6164 }
6165 if let Some(v) = self.version.as_ref() {
6166 struct_ser.serialize_field("version", v)?;
6167 }
6168 struct_ser.end()
6169 }
6170}
6171impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
6172 #[allow(deprecated)]
6173 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6174 where
6175 D: serde::Deserializer<'de>,
6176 {
6177 const FIELDS: &[&str] = &[
6178 "status",
6179 "version",
6180 ];
6181
6182 #[allow(clippy::enum_variant_names)]
6183 enum GeneratedField {
6184 Status,
6185 Version,
6186 }
6187 impl<'de> serde::Deserialize<'de> for GeneratedField {
6188 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6189 where
6190 D: serde::Deserializer<'de>,
6191 {
6192 struct GeneratedVisitor;
6193
6194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6195 type Value = GeneratedField;
6196
6197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6198 write!(formatter, "expected one of: {:?}", &FIELDS)
6199 }
6200
6201 #[allow(unused_variables)]
6202 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6203 where
6204 E: serde::de::Error,
6205 {
6206 match value {
6207 "status" => Ok(GeneratedField::Status),
6208 "version" => Ok(GeneratedField::Version),
6209 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6210 }
6211 }
6212 }
6213 deserializer.deserialize_identifier(GeneratedVisitor)
6214 }
6215 }
6216 struct GeneratedVisitor;
6217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6218 type Value = CreateSourceResponse;
6219
6220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6221 formatter.write_str("struct ddl_service.CreateSourceResponse")
6222 }
6223
6224 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
6225 where
6226 V: serde::de::MapAccess<'de>,
6227 {
6228 let mut status__ = None;
6229 let mut version__ = None;
6230 while let Some(k) = map_.next_key()? {
6231 match k {
6232 GeneratedField::Status => {
6233 if status__.is_some() {
6234 return Err(serde::de::Error::duplicate_field("status"));
6235 }
6236 status__ = map_.next_value()?;
6237 }
6238 GeneratedField::Version => {
6239 if version__.is_some() {
6240 return Err(serde::de::Error::duplicate_field("version"));
6241 }
6242 version__ = map_.next_value()?;
6243 }
6244 }
6245 }
6246 Ok(CreateSourceResponse {
6247 status: status__,
6248 version: version__,
6249 })
6250 }
6251 }
6252 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
6253 }
6254}
6255impl serde::Serialize for CreateSubscriptionRequest {
6256 #[allow(deprecated)]
6257 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6258 where
6259 S: serde::Serializer,
6260 {
6261 use serde::ser::SerializeStruct;
6262 let mut len = 0;
6263 if self.subscription.is_some() {
6264 len += 1;
6265 }
6266 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
6267 if let Some(v) = self.subscription.as_ref() {
6268 struct_ser.serialize_field("subscription", v)?;
6269 }
6270 struct_ser.end()
6271 }
6272}
6273impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
6274 #[allow(deprecated)]
6275 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6276 where
6277 D: serde::Deserializer<'de>,
6278 {
6279 const FIELDS: &[&str] = &[
6280 "subscription",
6281 ];
6282
6283 #[allow(clippy::enum_variant_names)]
6284 enum GeneratedField {
6285 Subscription,
6286 }
6287 impl<'de> serde::Deserialize<'de> for GeneratedField {
6288 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6289 where
6290 D: serde::Deserializer<'de>,
6291 {
6292 struct GeneratedVisitor;
6293
6294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6295 type Value = GeneratedField;
6296
6297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6298 write!(formatter, "expected one of: {:?}", &FIELDS)
6299 }
6300
6301 #[allow(unused_variables)]
6302 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6303 where
6304 E: serde::de::Error,
6305 {
6306 match value {
6307 "subscription" => Ok(GeneratedField::Subscription),
6308 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6309 }
6310 }
6311 }
6312 deserializer.deserialize_identifier(GeneratedVisitor)
6313 }
6314 }
6315 struct GeneratedVisitor;
6316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6317 type Value = CreateSubscriptionRequest;
6318
6319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6320 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
6321 }
6322
6323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
6324 where
6325 V: serde::de::MapAccess<'de>,
6326 {
6327 let mut subscription__ = None;
6328 while let Some(k) = map_.next_key()? {
6329 match k {
6330 GeneratedField::Subscription => {
6331 if subscription__.is_some() {
6332 return Err(serde::de::Error::duplicate_field("subscription"));
6333 }
6334 subscription__ = map_.next_value()?;
6335 }
6336 }
6337 }
6338 Ok(CreateSubscriptionRequest {
6339 subscription: subscription__,
6340 })
6341 }
6342 }
6343 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
6344 }
6345}
6346impl serde::Serialize for CreateSubscriptionResponse {
6347 #[allow(deprecated)]
6348 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6349 where
6350 S: serde::Serializer,
6351 {
6352 use serde::ser::SerializeStruct;
6353 let mut len = 0;
6354 if self.status.is_some() {
6355 len += 1;
6356 }
6357 if self.version.is_some() {
6358 len += 1;
6359 }
6360 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
6361 if let Some(v) = self.status.as_ref() {
6362 struct_ser.serialize_field("status", v)?;
6363 }
6364 if let Some(v) = self.version.as_ref() {
6365 struct_ser.serialize_field("version", v)?;
6366 }
6367 struct_ser.end()
6368 }
6369}
6370impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
6371 #[allow(deprecated)]
6372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6373 where
6374 D: serde::Deserializer<'de>,
6375 {
6376 const FIELDS: &[&str] = &[
6377 "status",
6378 "version",
6379 ];
6380
6381 #[allow(clippy::enum_variant_names)]
6382 enum GeneratedField {
6383 Status,
6384 Version,
6385 }
6386 impl<'de> serde::Deserialize<'de> for GeneratedField {
6387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6388 where
6389 D: serde::Deserializer<'de>,
6390 {
6391 struct GeneratedVisitor;
6392
6393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6394 type Value = GeneratedField;
6395
6396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6397 write!(formatter, "expected one of: {:?}", &FIELDS)
6398 }
6399
6400 #[allow(unused_variables)]
6401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6402 where
6403 E: serde::de::Error,
6404 {
6405 match value {
6406 "status" => Ok(GeneratedField::Status),
6407 "version" => Ok(GeneratedField::Version),
6408 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6409 }
6410 }
6411 }
6412 deserializer.deserialize_identifier(GeneratedVisitor)
6413 }
6414 }
6415 struct GeneratedVisitor;
6416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6417 type Value = CreateSubscriptionResponse;
6418
6419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6420 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
6421 }
6422
6423 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
6424 where
6425 V: serde::de::MapAccess<'de>,
6426 {
6427 let mut status__ = None;
6428 let mut version__ = None;
6429 while let Some(k) = map_.next_key()? {
6430 match k {
6431 GeneratedField::Status => {
6432 if status__.is_some() {
6433 return Err(serde::de::Error::duplicate_field("status"));
6434 }
6435 status__ = map_.next_value()?;
6436 }
6437 GeneratedField::Version => {
6438 if version__.is_some() {
6439 return Err(serde::de::Error::duplicate_field("version"));
6440 }
6441 version__ = map_.next_value()?;
6442 }
6443 }
6444 }
6445 Ok(CreateSubscriptionResponse {
6446 status: status__,
6447 version: version__,
6448 })
6449 }
6450 }
6451 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
6452 }
6453}
6454impl serde::Serialize for CreateTableRequest {
6455 #[allow(deprecated)]
6456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6457 where
6458 S: serde::Serializer,
6459 {
6460 use serde::ser::SerializeStruct;
6461 let mut len = 0;
6462 if self.source.is_some() {
6463 len += 1;
6464 }
6465 if self.materialized_view.is_some() {
6466 len += 1;
6467 }
6468 if self.fragment_graph.is_some() {
6469 len += 1;
6470 }
6471 if self.job_type != 0 {
6472 len += 1;
6473 }
6474 if self.if_not_exists {
6475 len += 1;
6476 }
6477 if !self.dependencies.is_empty() {
6478 len += 1;
6479 }
6480 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
6481 if let Some(v) = self.source.as_ref() {
6482 struct_ser.serialize_field("source", v)?;
6483 }
6484 if let Some(v) = self.materialized_view.as_ref() {
6485 struct_ser.serialize_field("materializedView", v)?;
6486 }
6487 if let Some(v) = self.fragment_graph.as_ref() {
6488 struct_ser.serialize_field("fragmentGraph", v)?;
6489 }
6490 if self.job_type != 0 {
6491 let v = TableJobType::try_from(self.job_type)
6492 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
6493 struct_ser.serialize_field("jobType", &v)?;
6494 }
6495 if self.if_not_exists {
6496 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
6497 }
6498 if !self.dependencies.is_empty() {
6499 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6500 }
6501 struct_ser.end()
6502 }
6503}
6504impl<'de> serde::Deserialize<'de> for CreateTableRequest {
6505 #[allow(deprecated)]
6506 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6507 where
6508 D: serde::Deserializer<'de>,
6509 {
6510 const FIELDS: &[&str] = &[
6511 "source",
6512 "materialized_view",
6513 "materializedView",
6514 "fragment_graph",
6515 "fragmentGraph",
6516 "job_type",
6517 "jobType",
6518 "if_not_exists",
6519 "ifNotExists",
6520 "dependencies",
6521 ];
6522
6523 #[allow(clippy::enum_variant_names)]
6524 enum GeneratedField {
6525 Source,
6526 MaterializedView,
6527 FragmentGraph,
6528 JobType,
6529 IfNotExists,
6530 Dependencies,
6531 }
6532 impl<'de> serde::Deserialize<'de> for GeneratedField {
6533 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6534 where
6535 D: serde::Deserializer<'de>,
6536 {
6537 struct GeneratedVisitor;
6538
6539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6540 type Value = GeneratedField;
6541
6542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6543 write!(formatter, "expected one of: {:?}", &FIELDS)
6544 }
6545
6546 #[allow(unused_variables)]
6547 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6548 where
6549 E: serde::de::Error,
6550 {
6551 match value {
6552 "source" => Ok(GeneratedField::Source),
6553 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
6554 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
6555 "jobType" | "job_type" => Ok(GeneratedField::JobType),
6556 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
6557 "dependencies" => Ok(GeneratedField::Dependencies),
6558 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6559 }
6560 }
6561 }
6562 deserializer.deserialize_identifier(GeneratedVisitor)
6563 }
6564 }
6565 struct GeneratedVisitor;
6566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6567 type Value = CreateTableRequest;
6568
6569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6570 formatter.write_str("struct ddl_service.CreateTableRequest")
6571 }
6572
6573 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
6574 where
6575 V: serde::de::MapAccess<'de>,
6576 {
6577 let mut source__ = None;
6578 let mut materialized_view__ = None;
6579 let mut fragment_graph__ = None;
6580 let mut job_type__ = None;
6581 let mut if_not_exists__ = None;
6582 let mut dependencies__ = None;
6583 while let Some(k) = map_.next_key()? {
6584 match k {
6585 GeneratedField::Source => {
6586 if source__.is_some() {
6587 return Err(serde::de::Error::duplicate_field("source"));
6588 }
6589 source__ = map_.next_value()?;
6590 }
6591 GeneratedField::MaterializedView => {
6592 if materialized_view__.is_some() {
6593 return Err(serde::de::Error::duplicate_field("materializedView"));
6594 }
6595 materialized_view__ = map_.next_value()?;
6596 }
6597 GeneratedField::FragmentGraph => {
6598 if fragment_graph__.is_some() {
6599 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
6600 }
6601 fragment_graph__ = map_.next_value()?;
6602 }
6603 GeneratedField::JobType => {
6604 if job_type__.is_some() {
6605 return Err(serde::de::Error::duplicate_field("jobType"));
6606 }
6607 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
6608 }
6609 GeneratedField::IfNotExists => {
6610 if if_not_exists__.is_some() {
6611 return Err(serde::de::Error::duplicate_field("ifNotExists"));
6612 }
6613 if_not_exists__ = Some(map_.next_value()?);
6614 }
6615 GeneratedField::Dependencies => {
6616 if dependencies__.is_some() {
6617 return Err(serde::de::Error::duplicate_field("dependencies"));
6618 }
6619 dependencies__ =
6620 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6621 .into_iter().map(|x| x.0).collect())
6622 ;
6623 }
6624 }
6625 }
6626 Ok(CreateTableRequest {
6627 source: source__,
6628 materialized_view: materialized_view__,
6629 fragment_graph: fragment_graph__,
6630 job_type: job_type__.unwrap_or_default(),
6631 if_not_exists: if_not_exists__.unwrap_or_default(),
6632 dependencies: dependencies__.unwrap_or_default(),
6633 })
6634 }
6635 }
6636 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
6637 }
6638}
6639impl serde::Serialize for CreateTableResponse {
6640 #[allow(deprecated)]
6641 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6642 where
6643 S: serde::Serializer,
6644 {
6645 use serde::ser::SerializeStruct;
6646 let mut len = 0;
6647 if self.status.is_some() {
6648 len += 1;
6649 }
6650 if self.version.is_some() {
6651 len += 1;
6652 }
6653 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
6654 if let Some(v) = self.status.as_ref() {
6655 struct_ser.serialize_field("status", v)?;
6656 }
6657 if let Some(v) = self.version.as_ref() {
6658 struct_ser.serialize_field("version", v)?;
6659 }
6660 struct_ser.end()
6661 }
6662}
6663impl<'de> serde::Deserialize<'de> for CreateTableResponse {
6664 #[allow(deprecated)]
6665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6666 where
6667 D: serde::Deserializer<'de>,
6668 {
6669 const FIELDS: &[&str] = &[
6670 "status",
6671 "version",
6672 ];
6673
6674 #[allow(clippy::enum_variant_names)]
6675 enum GeneratedField {
6676 Status,
6677 Version,
6678 }
6679 impl<'de> serde::Deserialize<'de> for GeneratedField {
6680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6681 where
6682 D: serde::Deserializer<'de>,
6683 {
6684 struct GeneratedVisitor;
6685
6686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6687 type Value = GeneratedField;
6688
6689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6690 write!(formatter, "expected one of: {:?}", &FIELDS)
6691 }
6692
6693 #[allow(unused_variables)]
6694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6695 where
6696 E: serde::de::Error,
6697 {
6698 match value {
6699 "status" => Ok(GeneratedField::Status),
6700 "version" => Ok(GeneratedField::Version),
6701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6702 }
6703 }
6704 }
6705 deserializer.deserialize_identifier(GeneratedVisitor)
6706 }
6707 }
6708 struct GeneratedVisitor;
6709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6710 type Value = CreateTableResponse;
6711
6712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6713 formatter.write_str("struct ddl_service.CreateTableResponse")
6714 }
6715
6716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
6717 where
6718 V: serde::de::MapAccess<'de>,
6719 {
6720 let mut status__ = None;
6721 let mut version__ = None;
6722 while let Some(k) = map_.next_key()? {
6723 match k {
6724 GeneratedField::Status => {
6725 if status__.is_some() {
6726 return Err(serde::de::Error::duplicate_field("status"));
6727 }
6728 status__ = map_.next_value()?;
6729 }
6730 GeneratedField::Version => {
6731 if version__.is_some() {
6732 return Err(serde::de::Error::duplicate_field("version"));
6733 }
6734 version__ = map_.next_value()?;
6735 }
6736 }
6737 }
6738 Ok(CreateTableResponse {
6739 status: status__,
6740 version: version__,
6741 })
6742 }
6743 }
6744 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
6745 }
6746}
6747impl serde::Serialize for CreateViewRequest {
6748 #[allow(deprecated)]
6749 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6750 where
6751 S: serde::Serializer,
6752 {
6753 use serde::ser::SerializeStruct;
6754 let mut len = 0;
6755 if self.view.is_some() {
6756 len += 1;
6757 }
6758 if !self.dependencies.is_empty() {
6759 len += 1;
6760 }
6761 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
6762 if let Some(v) = self.view.as_ref() {
6763 struct_ser.serialize_field("view", v)?;
6764 }
6765 if !self.dependencies.is_empty() {
6766 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6767 }
6768 struct_ser.end()
6769 }
6770}
6771impl<'de> serde::Deserialize<'de> for CreateViewRequest {
6772 #[allow(deprecated)]
6773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6774 where
6775 D: serde::Deserializer<'de>,
6776 {
6777 const FIELDS: &[&str] = &[
6778 "view",
6779 "dependencies",
6780 ];
6781
6782 #[allow(clippy::enum_variant_names)]
6783 enum GeneratedField {
6784 View,
6785 Dependencies,
6786 }
6787 impl<'de> serde::Deserialize<'de> for GeneratedField {
6788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6789 where
6790 D: serde::Deserializer<'de>,
6791 {
6792 struct GeneratedVisitor;
6793
6794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6795 type Value = GeneratedField;
6796
6797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6798 write!(formatter, "expected one of: {:?}", &FIELDS)
6799 }
6800
6801 #[allow(unused_variables)]
6802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6803 where
6804 E: serde::de::Error,
6805 {
6806 match value {
6807 "view" => Ok(GeneratedField::View),
6808 "dependencies" => Ok(GeneratedField::Dependencies),
6809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6810 }
6811 }
6812 }
6813 deserializer.deserialize_identifier(GeneratedVisitor)
6814 }
6815 }
6816 struct GeneratedVisitor;
6817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6818 type Value = CreateViewRequest;
6819
6820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6821 formatter.write_str("struct ddl_service.CreateViewRequest")
6822 }
6823
6824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
6825 where
6826 V: serde::de::MapAccess<'de>,
6827 {
6828 let mut view__ = None;
6829 let mut dependencies__ = None;
6830 while let Some(k) = map_.next_key()? {
6831 match k {
6832 GeneratedField::View => {
6833 if view__.is_some() {
6834 return Err(serde::de::Error::duplicate_field("view"));
6835 }
6836 view__ = map_.next_value()?;
6837 }
6838 GeneratedField::Dependencies => {
6839 if dependencies__.is_some() {
6840 return Err(serde::de::Error::duplicate_field("dependencies"));
6841 }
6842 dependencies__ =
6843 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6844 .into_iter().map(|x| x.0).collect())
6845 ;
6846 }
6847 }
6848 }
6849 Ok(CreateViewRequest {
6850 view: view__,
6851 dependencies: dependencies__.unwrap_or_default(),
6852 })
6853 }
6854 }
6855 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
6856 }
6857}
6858impl serde::Serialize for CreateViewResponse {
6859 #[allow(deprecated)]
6860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6861 where
6862 S: serde::Serializer,
6863 {
6864 use serde::ser::SerializeStruct;
6865 let mut len = 0;
6866 if self.status.is_some() {
6867 len += 1;
6868 }
6869 if self.version.is_some() {
6870 len += 1;
6871 }
6872 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
6873 if let Some(v) = self.status.as_ref() {
6874 struct_ser.serialize_field("status", v)?;
6875 }
6876 if let Some(v) = self.version.as_ref() {
6877 struct_ser.serialize_field("version", v)?;
6878 }
6879 struct_ser.end()
6880 }
6881}
6882impl<'de> serde::Deserialize<'de> for CreateViewResponse {
6883 #[allow(deprecated)]
6884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6885 where
6886 D: serde::Deserializer<'de>,
6887 {
6888 const FIELDS: &[&str] = &[
6889 "status",
6890 "version",
6891 ];
6892
6893 #[allow(clippy::enum_variant_names)]
6894 enum GeneratedField {
6895 Status,
6896 Version,
6897 }
6898 impl<'de> serde::Deserialize<'de> for GeneratedField {
6899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6900 where
6901 D: serde::Deserializer<'de>,
6902 {
6903 struct GeneratedVisitor;
6904
6905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6906 type Value = GeneratedField;
6907
6908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6909 write!(formatter, "expected one of: {:?}", &FIELDS)
6910 }
6911
6912 #[allow(unused_variables)]
6913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6914 where
6915 E: serde::de::Error,
6916 {
6917 match value {
6918 "status" => Ok(GeneratedField::Status),
6919 "version" => Ok(GeneratedField::Version),
6920 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6921 }
6922 }
6923 }
6924 deserializer.deserialize_identifier(GeneratedVisitor)
6925 }
6926 }
6927 struct GeneratedVisitor;
6928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6929 type Value = CreateViewResponse;
6930
6931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6932 formatter.write_str("struct ddl_service.CreateViewResponse")
6933 }
6934
6935 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
6936 where
6937 V: serde::de::MapAccess<'de>,
6938 {
6939 let mut status__ = None;
6940 let mut version__ = None;
6941 while let Some(k) = map_.next_key()? {
6942 match k {
6943 GeneratedField::Status => {
6944 if status__.is_some() {
6945 return Err(serde::de::Error::duplicate_field("status"));
6946 }
6947 status__ = map_.next_value()?;
6948 }
6949 GeneratedField::Version => {
6950 if version__.is_some() {
6951 return Err(serde::de::Error::duplicate_field("version"));
6952 }
6953 version__ = map_.next_value()?;
6954 }
6955 }
6956 }
6957 Ok(CreateViewResponse {
6958 status: status__,
6959 version: version__,
6960 })
6961 }
6962 }
6963 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
6964 }
6965}
6966impl serde::Serialize for DdlProgress {
6967 #[allow(deprecated)]
6968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6969 where
6970 S: serde::Serializer,
6971 {
6972 use serde::ser::SerializeStruct;
6973 let mut len = 0;
6974 if self.id != 0 {
6975 len += 1;
6976 }
6977 if !self.statement.is_empty() {
6978 len += 1;
6979 }
6980 if !self.progress.is_empty() {
6981 len += 1;
6982 }
6983 if !self.create_type.is_empty() {
6984 len += 1;
6985 }
6986 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
6987 if self.id != 0 {
6988 #[allow(clippy::needless_borrow)]
6989 #[allow(clippy::needless_borrows_for_generic_args)]
6990 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6991 }
6992 if !self.statement.is_empty() {
6993 struct_ser.serialize_field("statement", &self.statement)?;
6994 }
6995 if !self.progress.is_empty() {
6996 struct_ser.serialize_field("progress", &self.progress)?;
6997 }
6998 if !self.create_type.is_empty() {
6999 struct_ser.serialize_field("createType", &self.create_type)?;
7000 }
7001 struct_ser.end()
7002 }
7003}
7004impl<'de> serde::Deserialize<'de> for DdlProgress {
7005 #[allow(deprecated)]
7006 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7007 where
7008 D: serde::Deserializer<'de>,
7009 {
7010 const FIELDS: &[&str] = &[
7011 "id",
7012 "statement",
7013 "progress",
7014 "create_type",
7015 "createType",
7016 ];
7017
7018 #[allow(clippy::enum_variant_names)]
7019 enum GeneratedField {
7020 Id,
7021 Statement,
7022 Progress,
7023 CreateType,
7024 }
7025 impl<'de> serde::Deserialize<'de> for GeneratedField {
7026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7027 where
7028 D: serde::Deserializer<'de>,
7029 {
7030 struct GeneratedVisitor;
7031
7032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7033 type Value = GeneratedField;
7034
7035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7036 write!(formatter, "expected one of: {:?}", &FIELDS)
7037 }
7038
7039 #[allow(unused_variables)]
7040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7041 where
7042 E: serde::de::Error,
7043 {
7044 match value {
7045 "id" => Ok(GeneratedField::Id),
7046 "statement" => Ok(GeneratedField::Statement),
7047 "progress" => Ok(GeneratedField::Progress),
7048 "createType" | "create_type" => Ok(GeneratedField::CreateType),
7049 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7050 }
7051 }
7052 }
7053 deserializer.deserialize_identifier(GeneratedVisitor)
7054 }
7055 }
7056 struct GeneratedVisitor;
7057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7058 type Value = DdlProgress;
7059
7060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7061 formatter.write_str("struct ddl_service.DdlProgress")
7062 }
7063
7064 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
7065 where
7066 V: serde::de::MapAccess<'de>,
7067 {
7068 let mut id__ = None;
7069 let mut statement__ = None;
7070 let mut progress__ = None;
7071 let mut create_type__ = None;
7072 while let Some(k) = map_.next_key()? {
7073 match k {
7074 GeneratedField::Id => {
7075 if id__.is_some() {
7076 return Err(serde::de::Error::duplicate_field("id"));
7077 }
7078 id__ =
7079 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7080 ;
7081 }
7082 GeneratedField::Statement => {
7083 if statement__.is_some() {
7084 return Err(serde::de::Error::duplicate_field("statement"));
7085 }
7086 statement__ = Some(map_.next_value()?);
7087 }
7088 GeneratedField::Progress => {
7089 if progress__.is_some() {
7090 return Err(serde::de::Error::duplicate_field("progress"));
7091 }
7092 progress__ = Some(map_.next_value()?);
7093 }
7094 GeneratedField::CreateType => {
7095 if create_type__.is_some() {
7096 return Err(serde::de::Error::duplicate_field("createType"));
7097 }
7098 create_type__ = Some(map_.next_value()?);
7099 }
7100 }
7101 }
7102 Ok(DdlProgress {
7103 id: id__.unwrap_or_default(),
7104 statement: statement__.unwrap_or_default(),
7105 progress: progress__.unwrap_or_default(),
7106 create_type: create_type__.unwrap_or_default(),
7107 })
7108 }
7109 }
7110 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
7111 }
7112}
7113impl serde::Serialize for DropConnectionRequest {
7114 #[allow(deprecated)]
7115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7116 where
7117 S: serde::Serializer,
7118 {
7119 use serde::ser::SerializeStruct;
7120 let mut len = 0;
7121 if self.connection_id != 0 {
7122 len += 1;
7123 }
7124 if self.cascade {
7125 len += 1;
7126 }
7127 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
7128 if self.connection_id != 0 {
7129 struct_ser.serialize_field("connectionId", &self.connection_id)?;
7130 }
7131 if self.cascade {
7132 struct_ser.serialize_field("cascade", &self.cascade)?;
7133 }
7134 struct_ser.end()
7135 }
7136}
7137impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
7138 #[allow(deprecated)]
7139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7140 where
7141 D: serde::Deserializer<'de>,
7142 {
7143 const FIELDS: &[&str] = &[
7144 "connection_id",
7145 "connectionId",
7146 "cascade",
7147 ];
7148
7149 #[allow(clippy::enum_variant_names)]
7150 enum GeneratedField {
7151 ConnectionId,
7152 Cascade,
7153 }
7154 impl<'de> serde::Deserialize<'de> for GeneratedField {
7155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7156 where
7157 D: serde::Deserializer<'de>,
7158 {
7159 struct GeneratedVisitor;
7160
7161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7162 type Value = GeneratedField;
7163
7164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7165 write!(formatter, "expected one of: {:?}", &FIELDS)
7166 }
7167
7168 #[allow(unused_variables)]
7169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7170 where
7171 E: serde::de::Error,
7172 {
7173 match value {
7174 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
7175 "cascade" => Ok(GeneratedField::Cascade),
7176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7177 }
7178 }
7179 }
7180 deserializer.deserialize_identifier(GeneratedVisitor)
7181 }
7182 }
7183 struct GeneratedVisitor;
7184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7185 type Value = DropConnectionRequest;
7186
7187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7188 formatter.write_str("struct ddl_service.DropConnectionRequest")
7189 }
7190
7191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
7192 where
7193 V: serde::de::MapAccess<'de>,
7194 {
7195 let mut connection_id__ = None;
7196 let mut cascade__ = None;
7197 while let Some(k) = map_.next_key()? {
7198 match k {
7199 GeneratedField::ConnectionId => {
7200 if connection_id__.is_some() {
7201 return Err(serde::de::Error::duplicate_field("connectionId"));
7202 }
7203 connection_id__ =
7204 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7205 ;
7206 }
7207 GeneratedField::Cascade => {
7208 if cascade__.is_some() {
7209 return Err(serde::de::Error::duplicate_field("cascade"));
7210 }
7211 cascade__ = Some(map_.next_value()?);
7212 }
7213 }
7214 }
7215 Ok(DropConnectionRequest {
7216 connection_id: connection_id__.unwrap_or_default(),
7217 cascade: cascade__.unwrap_or_default(),
7218 })
7219 }
7220 }
7221 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
7222 }
7223}
7224impl serde::Serialize for DropConnectionResponse {
7225 #[allow(deprecated)]
7226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7227 where
7228 S: serde::Serializer,
7229 {
7230 use serde::ser::SerializeStruct;
7231 let mut len = 0;
7232 if self.status.is_some() {
7233 len += 1;
7234 }
7235 if self.version.is_some() {
7236 len += 1;
7237 }
7238 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
7239 if let Some(v) = self.status.as_ref() {
7240 struct_ser.serialize_field("status", v)?;
7241 }
7242 if let Some(v) = self.version.as_ref() {
7243 struct_ser.serialize_field("version", v)?;
7244 }
7245 struct_ser.end()
7246 }
7247}
7248impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
7249 #[allow(deprecated)]
7250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7251 where
7252 D: serde::Deserializer<'de>,
7253 {
7254 const FIELDS: &[&str] = &[
7255 "status",
7256 "version",
7257 ];
7258
7259 #[allow(clippy::enum_variant_names)]
7260 enum GeneratedField {
7261 Status,
7262 Version,
7263 }
7264 impl<'de> serde::Deserialize<'de> for GeneratedField {
7265 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7266 where
7267 D: serde::Deserializer<'de>,
7268 {
7269 struct GeneratedVisitor;
7270
7271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7272 type Value = GeneratedField;
7273
7274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7275 write!(formatter, "expected one of: {:?}", &FIELDS)
7276 }
7277
7278 #[allow(unused_variables)]
7279 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7280 where
7281 E: serde::de::Error,
7282 {
7283 match value {
7284 "status" => Ok(GeneratedField::Status),
7285 "version" => Ok(GeneratedField::Version),
7286 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7287 }
7288 }
7289 }
7290 deserializer.deserialize_identifier(GeneratedVisitor)
7291 }
7292 }
7293 struct GeneratedVisitor;
7294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7295 type Value = DropConnectionResponse;
7296
7297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7298 formatter.write_str("struct ddl_service.DropConnectionResponse")
7299 }
7300
7301 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
7302 where
7303 V: serde::de::MapAccess<'de>,
7304 {
7305 let mut status__ = None;
7306 let mut version__ = None;
7307 while let Some(k) = map_.next_key()? {
7308 match k {
7309 GeneratedField::Status => {
7310 if status__.is_some() {
7311 return Err(serde::de::Error::duplicate_field("status"));
7312 }
7313 status__ = map_.next_value()?;
7314 }
7315 GeneratedField::Version => {
7316 if version__.is_some() {
7317 return Err(serde::de::Error::duplicate_field("version"));
7318 }
7319 version__ = map_.next_value()?;
7320 }
7321 }
7322 }
7323 Ok(DropConnectionResponse {
7324 status: status__,
7325 version: version__,
7326 })
7327 }
7328 }
7329 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
7330 }
7331}
7332impl serde::Serialize for DropDatabaseRequest {
7333 #[allow(deprecated)]
7334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7335 where
7336 S: serde::Serializer,
7337 {
7338 use serde::ser::SerializeStruct;
7339 let mut len = 0;
7340 if self.database_id != 0 {
7341 len += 1;
7342 }
7343 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
7344 if self.database_id != 0 {
7345 struct_ser.serialize_field("databaseId", &self.database_id)?;
7346 }
7347 struct_ser.end()
7348 }
7349}
7350impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
7351 #[allow(deprecated)]
7352 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7353 where
7354 D: serde::Deserializer<'de>,
7355 {
7356 const FIELDS: &[&str] = &[
7357 "database_id",
7358 "databaseId",
7359 ];
7360
7361 #[allow(clippy::enum_variant_names)]
7362 enum GeneratedField {
7363 DatabaseId,
7364 }
7365 impl<'de> serde::Deserialize<'de> for GeneratedField {
7366 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7367 where
7368 D: serde::Deserializer<'de>,
7369 {
7370 struct GeneratedVisitor;
7371
7372 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7373 type Value = GeneratedField;
7374
7375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7376 write!(formatter, "expected one of: {:?}", &FIELDS)
7377 }
7378
7379 #[allow(unused_variables)]
7380 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7381 where
7382 E: serde::de::Error,
7383 {
7384 match value {
7385 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7386 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7387 }
7388 }
7389 }
7390 deserializer.deserialize_identifier(GeneratedVisitor)
7391 }
7392 }
7393 struct GeneratedVisitor;
7394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7395 type Value = DropDatabaseRequest;
7396
7397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7398 formatter.write_str("struct ddl_service.DropDatabaseRequest")
7399 }
7400
7401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
7402 where
7403 V: serde::de::MapAccess<'de>,
7404 {
7405 let mut database_id__ = None;
7406 while let Some(k) = map_.next_key()? {
7407 match k {
7408 GeneratedField::DatabaseId => {
7409 if database_id__.is_some() {
7410 return Err(serde::de::Error::duplicate_field("databaseId"));
7411 }
7412 database_id__ =
7413 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7414 ;
7415 }
7416 }
7417 }
7418 Ok(DropDatabaseRequest {
7419 database_id: database_id__.unwrap_or_default(),
7420 })
7421 }
7422 }
7423 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
7424 }
7425}
7426impl serde::Serialize for DropDatabaseResponse {
7427 #[allow(deprecated)]
7428 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7429 where
7430 S: serde::Serializer,
7431 {
7432 use serde::ser::SerializeStruct;
7433 let mut len = 0;
7434 if self.status.is_some() {
7435 len += 1;
7436 }
7437 if self.version.is_some() {
7438 len += 1;
7439 }
7440 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
7441 if let Some(v) = self.status.as_ref() {
7442 struct_ser.serialize_field("status", v)?;
7443 }
7444 if let Some(v) = self.version.as_ref() {
7445 struct_ser.serialize_field("version", v)?;
7446 }
7447 struct_ser.end()
7448 }
7449}
7450impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
7451 #[allow(deprecated)]
7452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7453 where
7454 D: serde::Deserializer<'de>,
7455 {
7456 const FIELDS: &[&str] = &[
7457 "status",
7458 "version",
7459 ];
7460
7461 #[allow(clippy::enum_variant_names)]
7462 enum GeneratedField {
7463 Status,
7464 Version,
7465 }
7466 impl<'de> serde::Deserialize<'de> for GeneratedField {
7467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7468 where
7469 D: serde::Deserializer<'de>,
7470 {
7471 struct GeneratedVisitor;
7472
7473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7474 type Value = GeneratedField;
7475
7476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7477 write!(formatter, "expected one of: {:?}", &FIELDS)
7478 }
7479
7480 #[allow(unused_variables)]
7481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7482 where
7483 E: serde::de::Error,
7484 {
7485 match value {
7486 "status" => Ok(GeneratedField::Status),
7487 "version" => Ok(GeneratedField::Version),
7488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7489 }
7490 }
7491 }
7492 deserializer.deserialize_identifier(GeneratedVisitor)
7493 }
7494 }
7495 struct GeneratedVisitor;
7496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7497 type Value = DropDatabaseResponse;
7498
7499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7500 formatter.write_str("struct ddl_service.DropDatabaseResponse")
7501 }
7502
7503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
7504 where
7505 V: serde::de::MapAccess<'de>,
7506 {
7507 let mut status__ = None;
7508 let mut version__ = None;
7509 while let Some(k) = map_.next_key()? {
7510 match k {
7511 GeneratedField::Status => {
7512 if status__.is_some() {
7513 return Err(serde::de::Error::duplicate_field("status"));
7514 }
7515 status__ = map_.next_value()?;
7516 }
7517 GeneratedField::Version => {
7518 if version__.is_some() {
7519 return Err(serde::de::Error::duplicate_field("version"));
7520 }
7521 version__ = map_.next_value()?;
7522 }
7523 }
7524 }
7525 Ok(DropDatabaseResponse {
7526 status: status__,
7527 version: version__,
7528 })
7529 }
7530 }
7531 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
7532 }
7533}
7534impl serde::Serialize for DropFunctionRequest {
7535 #[allow(deprecated)]
7536 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7537 where
7538 S: serde::Serializer,
7539 {
7540 use serde::ser::SerializeStruct;
7541 let mut len = 0;
7542 if self.function_id != 0 {
7543 len += 1;
7544 }
7545 if self.cascade {
7546 len += 1;
7547 }
7548 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
7549 if self.function_id != 0 {
7550 struct_ser.serialize_field("functionId", &self.function_id)?;
7551 }
7552 if self.cascade {
7553 struct_ser.serialize_field("cascade", &self.cascade)?;
7554 }
7555 struct_ser.end()
7556 }
7557}
7558impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
7559 #[allow(deprecated)]
7560 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7561 where
7562 D: serde::Deserializer<'de>,
7563 {
7564 const FIELDS: &[&str] = &[
7565 "function_id",
7566 "functionId",
7567 "cascade",
7568 ];
7569
7570 #[allow(clippy::enum_variant_names)]
7571 enum GeneratedField {
7572 FunctionId,
7573 Cascade,
7574 }
7575 impl<'de> serde::Deserialize<'de> for GeneratedField {
7576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7577 where
7578 D: serde::Deserializer<'de>,
7579 {
7580 struct GeneratedVisitor;
7581
7582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7583 type Value = GeneratedField;
7584
7585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7586 write!(formatter, "expected one of: {:?}", &FIELDS)
7587 }
7588
7589 #[allow(unused_variables)]
7590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7591 where
7592 E: serde::de::Error,
7593 {
7594 match value {
7595 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
7596 "cascade" => Ok(GeneratedField::Cascade),
7597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7598 }
7599 }
7600 }
7601 deserializer.deserialize_identifier(GeneratedVisitor)
7602 }
7603 }
7604 struct GeneratedVisitor;
7605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7606 type Value = DropFunctionRequest;
7607
7608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7609 formatter.write_str("struct ddl_service.DropFunctionRequest")
7610 }
7611
7612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
7613 where
7614 V: serde::de::MapAccess<'de>,
7615 {
7616 let mut function_id__ = None;
7617 let mut cascade__ = None;
7618 while let Some(k) = map_.next_key()? {
7619 match k {
7620 GeneratedField::FunctionId => {
7621 if function_id__.is_some() {
7622 return Err(serde::de::Error::duplicate_field("functionId"));
7623 }
7624 function_id__ =
7625 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7626 ;
7627 }
7628 GeneratedField::Cascade => {
7629 if cascade__.is_some() {
7630 return Err(serde::de::Error::duplicate_field("cascade"));
7631 }
7632 cascade__ = Some(map_.next_value()?);
7633 }
7634 }
7635 }
7636 Ok(DropFunctionRequest {
7637 function_id: function_id__.unwrap_or_default(),
7638 cascade: cascade__.unwrap_or_default(),
7639 })
7640 }
7641 }
7642 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
7643 }
7644}
7645impl serde::Serialize for DropFunctionResponse {
7646 #[allow(deprecated)]
7647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7648 where
7649 S: serde::Serializer,
7650 {
7651 use serde::ser::SerializeStruct;
7652 let mut len = 0;
7653 if self.status.is_some() {
7654 len += 1;
7655 }
7656 if self.version.is_some() {
7657 len += 1;
7658 }
7659 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
7660 if let Some(v) = self.status.as_ref() {
7661 struct_ser.serialize_field("status", v)?;
7662 }
7663 if let Some(v) = self.version.as_ref() {
7664 struct_ser.serialize_field("version", v)?;
7665 }
7666 struct_ser.end()
7667 }
7668}
7669impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
7670 #[allow(deprecated)]
7671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7672 where
7673 D: serde::Deserializer<'de>,
7674 {
7675 const FIELDS: &[&str] = &[
7676 "status",
7677 "version",
7678 ];
7679
7680 #[allow(clippy::enum_variant_names)]
7681 enum GeneratedField {
7682 Status,
7683 Version,
7684 }
7685 impl<'de> serde::Deserialize<'de> for GeneratedField {
7686 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7687 where
7688 D: serde::Deserializer<'de>,
7689 {
7690 struct GeneratedVisitor;
7691
7692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7693 type Value = GeneratedField;
7694
7695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7696 write!(formatter, "expected one of: {:?}", &FIELDS)
7697 }
7698
7699 #[allow(unused_variables)]
7700 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7701 where
7702 E: serde::de::Error,
7703 {
7704 match value {
7705 "status" => Ok(GeneratedField::Status),
7706 "version" => Ok(GeneratedField::Version),
7707 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7708 }
7709 }
7710 }
7711 deserializer.deserialize_identifier(GeneratedVisitor)
7712 }
7713 }
7714 struct GeneratedVisitor;
7715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7716 type Value = DropFunctionResponse;
7717
7718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7719 formatter.write_str("struct ddl_service.DropFunctionResponse")
7720 }
7721
7722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
7723 where
7724 V: serde::de::MapAccess<'de>,
7725 {
7726 let mut status__ = None;
7727 let mut version__ = None;
7728 while let Some(k) = map_.next_key()? {
7729 match k {
7730 GeneratedField::Status => {
7731 if status__.is_some() {
7732 return Err(serde::de::Error::duplicate_field("status"));
7733 }
7734 status__ = map_.next_value()?;
7735 }
7736 GeneratedField::Version => {
7737 if version__.is_some() {
7738 return Err(serde::de::Error::duplicate_field("version"));
7739 }
7740 version__ = map_.next_value()?;
7741 }
7742 }
7743 }
7744 Ok(DropFunctionResponse {
7745 status: status__,
7746 version: version__,
7747 })
7748 }
7749 }
7750 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
7751 }
7752}
7753impl serde::Serialize for DropIndexRequest {
7754 #[allow(deprecated)]
7755 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7756 where
7757 S: serde::Serializer,
7758 {
7759 use serde::ser::SerializeStruct;
7760 let mut len = 0;
7761 if self.index_id != 0 {
7762 len += 1;
7763 }
7764 if self.cascade {
7765 len += 1;
7766 }
7767 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
7768 if self.index_id != 0 {
7769 struct_ser.serialize_field("indexId", &self.index_id)?;
7770 }
7771 if self.cascade {
7772 struct_ser.serialize_field("cascade", &self.cascade)?;
7773 }
7774 struct_ser.end()
7775 }
7776}
7777impl<'de> serde::Deserialize<'de> for DropIndexRequest {
7778 #[allow(deprecated)]
7779 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7780 where
7781 D: serde::Deserializer<'de>,
7782 {
7783 const FIELDS: &[&str] = &[
7784 "index_id",
7785 "indexId",
7786 "cascade",
7787 ];
7788
7789 #[allow(clippy::enum_variant_names)]
7790 enum GeneratedField {
7791 IndexId,
7792 Cascade,
7793 }
7794 impl<'de> serde::Deserialize<'de> for GeneratedField {
7795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7796 where
7797 D: serde::Deserializer<'de>,
7798 {
7799 struct GeneratedVisitor;
7800
7801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7802 type Value = GeneratedField;
7803
7804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7805 write!(formatter, "expected one of: {:?}", &FIELDS)
7806 }
7807
7808 #[allow(unused_variables)]
7809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7810 where
7811 E: serde::de::Error,
7812 {
7813 match value {
7814 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7815 "cascade" => Ok(GeneratedField::Cascade),
7816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7817 }
7818 }
7819 }
7820 deserializer.deserialize_identifier(GeneratedVisitor)
7821 }
7822 }
7823 struct GeneratedVisitor;
7824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7825 type Value = DropIndexRequest;
7826
7827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7828 formatter.write_str("struct ddl_service.DropIndexRequest")
7829 }
7830
7831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
7832 where
7833 V: serde::de::MapAccess<'de>,
7834 {
7835 let mut index_id__ = None;
7836 let mut cascade__ = None;
7837 while let Some(k) = map_.next_key()? {
7838 match k {
7839 GeneratedField::IndexId => {
7840 if index_id__.is_some() {
7841 return Err(serde::de::Error::duplicate_field("indexId"));
7842 }
7843 index_id__ =
7844 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7845 ;
7846 }
7847 GeneratedField::Cascade => {
7848 if cascade__.is_some() {
7849 return Err(serde::de::Error::duplicate_field("cascade"));
7850 }
7851 cascade__ = Some(map_.next_value()?);
7852 }
7853 }
7854 }
7855 Ok(DropIndexRequest {
7856 index_id: index_id__.unwrap_or_default(),
7857 cascade: cascade__.unwrap_or_default(),
7858 })
7859 }
7860 }
7861 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
7862 }
7863}
7864impl serde::Serialize for DropIndexResponse {
7865 #[allow(deprecated)]
7866 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7867 where
7868 S: serde::Serializer,
7869 {
7870 use serde::ser::SerializeStruct;
7871 let mut len = 0;
7872 if self.status.is_some() {
7873 len += 1;
7874 }
7875 if self.version.is_some() {
7876 len += 1;
7877 }
7878 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
7879 if let Some(v) = self.status.as_ref() {
7880 struct_ser.serialize_field("status", v)?;
7881 }
7882 if let Some(v) = self.version.as_ref() {
7883 struct_ser.serialize_field("version", v)?;
7884 }
7885 struct_ser.end()
7886 }
7887}
7888impl<'de> serde::Deserialize<'de> for DropIndexResponse {
7889 #[allow(deprecated)]
7890 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7891 where
7892 D: serde::Deserializer<'de>,
7893 {
7894 const FIELDS: &[&str] = &[
7895 "status",
7896 "version",
7897 ];
7898
7899 #[allow(clippy::enum_variant_names)]
7900 enum GeneratedField {
7901 Status,
7902 Version,
7903 }
7904 impl<'de> serde::Deserialize<'de> for GeneratedField {
7905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7906 where
7907 D: serde::Deserializer<'de>,
7908 {
7909 struct GeneratedVisitor;
7910
7911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7912 type Value = GeneratedField;
7913
7914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7915 write!(formatter, "expected one of: {:?}", &FIELDS)
7916 }
7917
7918 #[allow(unused_variables)]
7919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7920 where
7921 E: serde::de::Error,
7922 {
7923 match value {
7924 "status" => Ok(GeneratedField::Status),
7925 "version" => Ok(GeneratedField::Version),
7926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7927 }
7928 }
7929 }
7930 deserializer.deserialize_identifier(GeneratedVisitor)
7931 }
7932 }
7933 struct GeneratedVisitor;
7934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7935 type Value = DropIndexResponse;
7936
7937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7938 formatter.write_str("struct ddl_service.DropIndexResponse")
7939 }
7940
7941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
7942 where
7943 V: serde::de::MapAccess<'de>,
7944 {
7945 let mut status__ = None;
7946 let mut version__ = None;
7947 while let Some(k) = map_.next_key()? {
7948 match k {
7949 GeneratedField::Status => {
7950 if status__.is_some() {
7951 return Err(serde::de::Error::duplicate_field("status"));
7952 }
7953 status__ = map_.next_value()?;
7954 }
7955 GeneratedField::Version => {
7956 if version__.is_some() {
7957 return Err(serde::de::Error::duplicate_field("version"));
7958 }
7959 version__ = map_.next_value()?;
7960 }
7961 }
7962 }
7963 Ok(DropIndexResponse {
7964 status: status__,
7965 version: version__,
7966 })
7967 }
7968 }
7969 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
7970 }
7971}
7972impl serde::Serialize for DropMaterializedViewRequest {
7973 #[allow(deprecated)]
7974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7975 where
7976 S: serde::Serializer,
7977 {
7978 use serde::ser::SerializeStruct;
7979 let mut len = 0;
7980 if self.table_id != 0 {
7981 len += 1;
7982 }
7983 if self.cascade {
7984 len += 1;
7985 }
7986 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
7987 if self.table_id != 0 {
7988 struct_ser.serialize_field("tableId", &self.table_id)?;
7989 }
7990 if self.cascade {
7991 struct_ser.serialize_field("cascade", &self.cascade)?;
7992 }
7993 struct_ser.end()
7994 }
7995}
7996impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
7997 #[allow(deprecated)]
7998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7999 where
8000 D: serde::Deserializer<'de>,
8001 {
8002 const FIELDS: &[&str] = &[
8003 "table_id",
8004 "tableId",
8005 "cascade",
8006 ];
8007
8008 #[allow(clippy::enum_variant_names)]
8009 enum GeneratedField {
8010 TableId,
8011 Cascade,
8012 }
8013 impl<'de> serde::Deserialize<'de> for GeneratedField {
8014 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8015 where
8016 D: serde::Deserializer<'de>,
8017 {
8018 struct GeneratedVisitor;
8019
8020 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8021 type Value = GeneratedField;
8022
8023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8024 write!(formatter, "expected one of: {:?}", &FIELDS)
8025 }
8026
8027 #[allow(unused_variables)]
8028 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8029 where
8030 E: serde::de::Error,
8031 {
8032 match value {
8033 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8034 "cascade" => Ok(GeneratedField::Cascade),
8035 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8036 }
8037 }
8038 }
8039 deserializer.deserialize_identifier(GeneratedVisitor)
8040 }
8041 }
8042 struct GeneratedVisitor;
8043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8044 type Value = DropMaterializedViewRequest;
8045
8046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8047 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
8048 }
8049
8050 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
8051 where
8052 V: serde::de::MapAccess<'de>,
8053 {
8054 let mut table_id__ = None;
8055 let mut cascade__ = None;
8056 while let Some(k) = map_.next_key()? {
8057 match k {
8058 GeneratedField::TableId => {
8059 if table_id__.is_some() {
8060 return Err(serde::de::Error::duplicate_field("tableId"));
8061 }
8062 table_id__ =
8063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8064 ;
8065 }
8066 GeneratedField::Cascade => {
8067 if cascade__.is_some() {
8068 return Err(serde::de::Error::duplicate_field("cascade"));
8069 }
8070 cascade__ = Some(map_.next_value()?);
8071 }
8072 }
8073 }
8074 Ok(DropMaterializedViewRequest {
8075 table_id: table_id__.unwrap_or_default(),
8076 cascade: cascade__.unwrap_or_default(),
8077 })
8078 }
8079 }
8080 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
8081 }
8082}
8083impl serde::Serialize for DropMaterializedViewResponse {
8084 #[allow(deprecated)]
8085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8086 where
8087 S: serde::Serializer,
8088 {
8089 use serde::ser::SerializeStruct;
8090 let mut len = 0;
8091 if self.status.is_some() {
8092 len += 1;
8093 }
8094 if self.version.is_some() {
8095 len += 1;
8096 }
8097 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
8098 if let Some(v) = self.status.as_ref() {
8099 struct_ser.serialize_field("status", v)?;
8100 }
8101 if let Some(v) = self.version.as_ref() {
8102 struct_ser.serialize_field("version", v)?;
8103 }
8104 struct_ser.end()
8105 }
8106}
8107impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
8108 #[allow(deprecated)]
8109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8110 where
8111 D: serde::Deserializer<'de>,
8112 {
8113 const FIELDS: &[&str] = &[
8114 "status",
8115 "version",
8116 ];
8117
8118 #[allow(clippy::enum_variant_names)]
8119 enum GeneratedField {
8120 Status,
8121 Version,
8122 }
8123 impl<'de> serde::Deserialize<'de> for GeneratedField {
8124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8125 where
8126 D: serde::Deserializer<'de>,
8127 {
8128 struct GeneratedVisitor;
8129
8130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8131 type Value = GeneratedField;
8132
8133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8134 write!(formatter, "expected one of: {:?}", &FIELDS)
8135 }
8136
8137 #[allow(unused_variables)]
8138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8139 where
8140 E: serde::de::Error,
8141 {
8142 match value {
8143 "status" => Ok(GeneratedField::Status),
8144 "version" => Ok(GeneratedField::Version),
8145 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8146 }
8147 }
8148 }
8149 deserializer.deserialize_identifier(GeneratedVisitor)
8150 }
8151 }
8152 struct GeneratedVisitor;
8153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8154 type Value = DropMaterializedViewResponse;
8155
8156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8157 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
8158 }
8159
8160 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
8161 where
8162 V: serde::de::MapAccess<'de>,
8163 {
8164 let mut status__ = None;
8165 let mut version__ = None;
8166 while let Some(k) = map_.next_key()? {
8167 match k {
8168 GeneratedField::Status => {
8169 if status__.is_some() {
8170 return Err(serde::de::Error::duplicate_field("status"));
8171 }
8172 status__ = map_.next_value()?;
8173 }
8174 GeneratedField::Version => {
8175 if version__.is_some() {
8176 return Err(serde::de::Error::duplicate_field("version"));
8177 }
8178 version__ = map_.next_value()?;
8179 }
8180 }
8181 }
8182 Ok(DropMaterializedViewResponse {
8183 status: status__,
8184 version: version__,
8185 })
8186 }
8187 }
8188 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
8189 }
8190}
8191impl serde::Serialize for DropSchemaRequest {
8192 #[allow(deprecated)]
8193 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8194 where
8195 S: serde::Serializer,
8196 {
8197 use serde::ser::SerializeStruct;
8198 let mut len = 0;
8199 if self.schema_id != 0 {
8200 len += 1;
8201 }
8202 if self.cascade {
8203 len += 1;
8204 }
8205 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
8206 if self.schema_id != 0 {
8207 struct_ser.serialize_field("schemaId", &self.schema_id)?;
8208 }
8209 if self.cascade {
8210 struct_ser.serialize_field("cascade", &self.cascade)?;
8211 }
8212 struct_ser.end()
8213 }
8214}
8215impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
8216 #[allow(deprecated)]
8217 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8218 where
8219 D: serde::Deserializer<'de>,
8220 {
8221 const FIELDS: &[&str] = &[
8222 "schema_id",
8223 "schemaId",
8224 "cascade",
8225 ];
8226
8227 #[allow(clippy::enum_variant_names)]
8228 enum GeneratedField {
8229 SchemaId,
8230 Cascade,
8231 }
8232 impl<'de> serde::Deserialize<'de> for GeneratedField {
8233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8234 where
8235 D: serde::Deserializer<'de>,
8236 {
8237 struct GeneratedVisitor;
8238
8239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8240 type Value = GeneratedField;
8241
8242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8243 write!(formatter, "expected one of: {:?}", &FIELDS)
8244 }
8245
8246 #[allow(unused_variables)]
8247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8248 where
8249 E: serde::de::Error,
8250 {
8251 match value {
8252 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
8253 "cascade" => Ok(GeneratedField::Cascade),
8254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8255 }
8256 }
8257 }
8258 deserializer.deserialize_identifier(GeneratedVisitor)
8259 }
8260 }
8261 struct GeneratedVisitor;
8262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8263 type Value = DropSchemaRequest;
8264
8265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8266 formatter.write_str("struct ddl_service.DropSchemaRequest")
8267 }
8268
8269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
8270 where
8271 V: serde::de::MapAccess<'de>,
8272 {
8273 let mut schema_id__ = None;
8274 let mut cascade__ = None;
8275 while let Some(k) = map_.next_key()? {
8276 match k {
8277 GeneratedField::SchemaId => {
8278 if schema_id__.is_some() {
8279 return Err(serde::de::Error::duplicate_field("schemaId"));
8280 }
8281 schema_id__ =
8282 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8283 ;
8284 }
8285 GeneratedField::Cascade => {
8286 if cascade__.is_some() {
8287 return Err(serde::de::Error::duplicate_field("cascade"));
8288 }
8289 cascade__ = Some(map_.next_value()?);
8290 }
8291 }
8292 }
8293 Ok(DropSchemaRequest {
8294 schema_id: schema_id__.unwrap_or_default(),
8295 cascade: cascade__.unwrap_or_default(),
8296 })
8297 }
8298 }
8299 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
8300 }
8301}
8302impl serde::Serialize for DropSchemaResponse {
8303 #[allow(deprecated)]
8304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8305 where
8306 S: serde::Serializer,
8307 {
8308 use serde::ser::SerializeStruct;
8309 let mut len = 0;
8310 if self.status.is_some() {
8311 len += 1;
8312 }
8313 if self.version.is_some() {
8314 len += 1;
8315 }
8316 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
8317 if let Some(v) = self.status.as_ref() {
8318 struct_ser.serialize_field("status", v)?;
8319 }
8320 if let Some(v) = self.version.as_ref() {
8321 struct_ser.serialize_field("version", v)?;
8322 }
8323 struct_ser.end()
8324 }
8325}
8326impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
8327 #[allow(deprecated)]
8328 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8329 where
8330 D: serde::Deserializer<'de>,
8331 {
8332 const FIELDS: &[&str] = &[
8333 "status",
8334 "version",
8335 ];
8336
8337 #[allow(clippy::enum_variant_names)]
8338 enum GeneratedField {
8339 Status,
8340 Version,
8341 }
8342 impl<'de> serde::Deserialize<'de> for GeneratedField {
8343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8344 where
8345 D: serde::Deserializer<'de>,
8346 {
8347 struct GeneratedVisitor;
8348
8349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8350 type Value = GeneratedField;
8351
8352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8353 write!(formatter, "expected one of: {:?}", &FIELDS)
8354 }
8355
8356 #[allow(unused_variables)]
8357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8358 where
8359 E: serde::de::Error,
8360 {
8361 match value {
8362 "status" => Ok(GeneratedField::Status),
8363 "version" => Ok(GeneratedField::Version),
8364 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8365 }
8366 }
8367 }
8368 deserializer.deserialize_identifier(GeneratedVisitor)
8369 }
8370 }
8371 struct GeneratedVisitor;
8372 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8373 type Value = DropSchemaResponse;
8374
8375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8376 formatter.write_str("struct ddl_service.DropSchemaResponse")
8377 }
8378
8379 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
8380 where
8381 V: serde::de::MapAccess<'de>,
8382 {
8383 let mut status__ = None;
8384 let mut version__ = None;
8385 while let Some(k) = map_.next_key()? {
8386 match k {
8387 GeneratedField::Status => {
8388 if status__.is_some() {
8389 return Err(serde::de::Error::duplicate_field("status"));
8390 }
8391 status__ = map_.next_value()?;
8392 }
8393 GeneratedField::Version => {
8394 if version__.is_some() {
8395 return Err(serde::de::Error::duplicate_field("version"));
8396 }
8397 version__ = map_.next_value()?;
8398 }
8399 }
8400 }
8401 Ok(DropSchemaResponse {
8402 status: status__,
8403 version: version__,
8404 })
8405 }
8406 }
8407 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
8408 }
8409}
8410impl serde::Serialize for DropSecretRequest {
8411 #[allow(deprecated)]
8412 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8413 where
8414 S: serde::Serializer,
8415 {
8416 use serde::ser::SerializeStruct;
8417 let mut len = 0;
8418 if self.secret_id != 0 {
8419 len += 1;
8420 }
8421 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
8422 if self.secret_id != 0 {
8423 struct_ser.serialize_field("secretId", &self.secret_id)?;
8424 }
8425 struct_ser.end()
8426 }
8427}
8428impl<'de> serde::Deserialize<'de> for DropSecretRequest {
8429 #[allow(deprecated)]
8430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8431 where
8432 D: serde::Deserializer<'de>,
8433 {
8434 const FIELDS: &[&str] = &[
8435 "secret_id",
8436 "secretId",
8437 ];
8438
8439 #[allow(clippy::enum_variant_names)]
8440 enum GeneratedField {
8441 SecretId,
8442 }
8443 impl<'de> serde::Deserialize<'de> for GeneratedField {
8444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8445 where
8446 D: serde::Deserializer<'de>,
8447 {
8448 struct GeneratedVisitor;
8449
8450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8451 type Value = GeneratedField;
8452
8453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8454 write!(formatter, "expected one of: {:?}", &FIELDS)
8455 }
8456
8457 #[allow(unused_variables)]
8458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8459 where
8460 E: serde::de::Error,
8461 {
8462 match value {
8463 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
8464 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8465 }
8466 }
8467 }
8468 deserializer.deserialize_identifier(GeneratedVisitor)
8469 }
8470 }
8471 struct GeneratedVisitor;
8472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8473 type Value = DropSecretRequest;
8474
8475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8476 formatter.write_str("struct ddl_service.DropSecretRequest")
8477 }
8478
8479 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
8480 where
8481 V: serde::de::MapAccess<'de>,
8482 {
8483 let mut secret_id__ = None;
8484 while let Some(k) = map_.next_key()? {
8485 match k {
8486 GeneratedField::SecretId => {
8487 if secret_id__.is_some() {
8488 return Err(serde::de::Error::duplicate_field("secretId"));
8489 }
8490 secret_id__ =
8491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8492 ;
8493 }
8494 }
8495 }
8496 Ok(DropSecretRequest {
8497 secret_id: secret_id__.unwrap_or_default(),
8498 })
8499 }
8500 }
8501 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
8502 }
8503}
8504impl serde::Serialize for DropSecretResponse {
8505 #[allow(deprecated)]
8506 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8507 where
8508 S: serde::Serializer,
8509 {
8510 use serde::ser::SerializeStruct;
8511 let mut len = 0;
8512 if self.version.is_some() {
8513 len += 1;
8514 }
8515 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
8516 if let Some(v) = self.version.as_ref() {
8517 struct_ser.serialize_field("version", v)?;
8518 }
8519 struct_ser.end()
8520 }
8521}
8522impl<'de> serde::Deserialize<'de> for DropSecretResponse {
8523 #[allow(deprecated)]
8524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8525 where
8526 D: serde::Deserializer<'de>,
8527 {
8528 const FIELDS: &[&str] = &[
8529 "version",
8530 ];
8531
8532 #[allow(clippy::enum_variant_names)]
8533 enum GeneratedField {
8534 Version,
8535 }
8536 impl<'de> serde::Deserialize<'de> for GeneratedField {
8537 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8538 where
8539 D: serde::Deserializer<'de>,
8540 {
8541 struct GeneratedVisitor;
8542
8543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8544 type Value = GeneratedField;
8545
8546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8547 write!(formatter, "expected one of: {:?}", &FIELDS)
8548 }
8549
8550 #[allow(unused_variables)]
8551 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8552 where
8553 E: serde::de::Error,
8554 {
8555 match value {
8556 "version" => Ok(GeneratedField::Version),
8557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8558 }
8559 }
8560 }
8561 deserializer.deserialize_identifier(GeneratedVisitor)
8562 }
8563 }
8564 struct GeneratedVisitor;
8565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8566 type Value = DropSecretResponse;
8567
8568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8569 formatter.write_str("struct ddl_service.DropSecretResponse")
8570 }
8571
8572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
8573 where
8574 V: serde::de::MapAccess<'de>,
8575 {
8576 let mut version__ = None;
8577 while let Some(k) = map_.next_key()? {
8578 match k {
8579 GeneratedField::Version => {
8580 if version__.is_some() {
8581 return Err(serde::de::Error::duplicate_field("version"));
8582 }
8583 version__ = map_.next_value()?;
8584 }
8585 }
8586 }
8587 Ok(DropSecretResponse {
8588 version: version__,
8589 })
8590 }
8591 }
8592 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
8593 }
8594}
8595impl serde::Serialize for DropSinkRequest {
8596 #[allow(deprecated)]
8597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8598 where
8599 S: serde::Serializer,
8600 {
8601 use serde::ser::SerializeStruct;
8602 let mut len = 0;
8603 if self.sink_id != 0 {
8604 len += 1;
8605 }
8606 if self.cascade {
8607 len += 1;
8608 }
8609 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
8610 if self.sink_id != 0 {
8611 struct_ser.serialize_field("sinkId", &self.sink_id)?;
8612 }
8613 if self.cascade {
8614 struct_ser.serialize_field("cascade", &self.cascade)?;
8615 }
8616 struct_ser.end()
8617 }
8618}
8619impl<'de> serde::Deserialize<'de> for DropSinkRequest {
8620 #[allow(deprecated)]
8621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8622 where
8623 D: serde::Deserializer<'de>,
8624 {
8625 const FIELDS: &[&str] = &[
8626 "sink_id",
8627 "sinkId",
8628 "cascade",
8629 ];
8630
8631 #[allow(clippy::enum_variant_names)]
8632 enum GeneratedField {
8633 SinkId,
8634 Cascade,
8635 }
8636 impl<'de> serde::Deserialize<'de> for GeneratedField {
8637 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8638 where
8639 D: serde::Deserializer<'de>,
8640 {
8641 struct GeneratedVisitor;
8642
8643 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8644 type Value = GeneratedField;
8645
8646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8647 write!(formatter, "expected one of: {:?}", &FIELDS)
8648 }
8649
8650 #[allow(unused_variables)]
8651 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8652 where
8653 E: serde::de::Error,
8654 {
8655 match value {
8656 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
8657 "cascade" => Ok(GeneratedField::Cascade),
8658 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8659 }
8660 }
8661 }
8662 deserializer.deserialize_identifier(GeneratedVisitor)
8663 }
8664 }
8665 struct GeneratedVisitor;
8666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8667 type Value = DropSinkRequest;
8668
8669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8670 formatter.write_str("struct ddl_service.DropSinkRequest")
8671 }
8672
8673 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
8674 where
8675 V: serde::de::MapAccess<'de>,
8676 {
8677 let mut sink_id__ = None;
8678 let mut cascade__ = None;
8679 while let Some(k) = map_.next_key()? {
8680 match k {
8681 GeneratedField::SinkId => {
8682 if sink_id__.is_some() {
8683 return Err(serde::de::Error::duplicate_field("sinkId"));
8684 }
8685 sink_id__ =
8686 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8687 ;
8688 }
8689 GeneratedField::Cascade => {
8690 if cascade__.is_some() {
8691 return Err(serde::de::Error::duplicate_field("cascade"));
8692 }
8693 cascade__ = Some(map_.next_value()?);
8694 }
8695 }
8696 }
8697 Ok(DropSinkRequest {
8698 sink_id: sink_id__.unwrap_or_default(),
8699 cascade: cascade__.unwrap_or_default(),
8700 })
8701 }
8702 }
8703 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
8704 }
8705}
8706impl serde::Serialize for DropSinkResponse {
8707 #[allow(deprecated)]
8708 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8709 where
8710 S: serde::Serializer,
8711 {
8712 use serde::ser::SerializeStruct;
8713 let mut len = 0;
8714 if self.status.is_some() {
8715 len += 1;
8716 }
8717 if self.version.is_some() {
8718 len += 1;
8719 }
8720 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
8721 if let Some(v) = self.status.as_ref() {
8722 struct_ser.serialize_field("status", v)?;
8723 }
8724 if let Some(v) = self.version.as_ref() {
8725 struct_ser.serialize_field("version", v)?;
8726 }
8727 struct_ser.end()
8728 }
8729}
8730impl<'de> serde::Deserialize<'de> for DropSinkResponse {
8731 #[allow(deprecated)]
8732 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8733 where
8734 D: serde::Deserializer<'de>,
8735 {
8736 const FIELDS: &[&str] = &[
8737 "status",
8738 "version",
8739 ];
8740
8741 #[allow(clippy::enum_variant_names)]
8742 enum GeneratedField {
8743 Status,
8744 Version,
8745 }
8746 impl<'de> serde::Deserialize<'de> for GeneratedField {
8747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8748 where
8749 D: serde::Deserializer<'de>,
8750 {
8751 struct GeneratedVisitor;
8752
8753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8754 type Value = GeneratedField;
8755
8756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8757 write!(formatter, "expected one of: {:?}", &FIELDS)
8758 }
8759
8760 #[allow(unused_variables)]
8761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8762 where
8763 E: serde::de::Error,
8764 {
8765 match value {
8766 "status" => Ok(GeneratedField::Status),
8767 "version" => Ok(GeneratedField::Version),
8768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8769 }
8770 }
8771 }
8772 deserializer.deserialize_identifier(GeneratedVisitor)
8773 }
8774 }
8775 struct GeneratedVisitor;
8776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8777 type Value = DropSinkResponse;
8778
8779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8780 formatter.write_str("struct ddl_service.DropSinkResponse")
8781 }
8782
8783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
8784 where
8785 V: serde::de::MapAccess<'de>,
8786 {
8787 let mut status__ = None;
8788 let mut version__ = None;
8789 while let Some(k) = map_.next_key()? {
8790 match k {
8791 GeneratedField::Status => {
8792 if status__.is_some() {
8793 return Err(serde::de::Error::duplicate_field("status"));
8794 }
8795 status__ = map_.next_value()?;
8796 }
8797 GeneratedField::Version => {
8798 if version__.is_some() {
8799 return Err(serde::de::Error::duplicate_field("version"));
8800 }
8801 version__ = map_.next_value()?;
8802 }
8803 }
8804 }
8805 Ok(DropSinkResponse {
8806 status: status__,
8807 version: version__,
8808 })
8809 }
8810 }
8811 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
8812 }
8813}
8814impl serde::Serialize for DropSourceRequest {
8815 #[allow(deprecated)]
8816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8817 where
8818 S: serde::Serializer,
8819 {
8820 use serde::ser::SerializeStruct;
8821 let mut len = 0;
8822 if self.source_id != 0 {
8823 len += 1;
8824 }
8825 if self.cascade {
8826 len += 1;
8827 }
8828 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
8829 if self.source_id != 0 {
8830 struct_ser.serialize_field("sourceId", &self.source_id)?;
8831 }
8832 if self.cascade {
8833 struct_ser.serialize_field("cascade", &self.cascade)?;
8834 }
8835 struct_ser.end()
8836 }
8837}
8838impl<'de> serde::Deserialize<'de> for DropSourceRequest {
8839 #[allow(deprecated)]
8840 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8841 where
8842 D: serde::Deserializer<'de>,
8843 {
8844 const FIELDS: &[&str] = &[
8845 "source_id",
8846 "sourceId",
8847 "cascade",
8848 ];
8849
8850 #[allow(clippy::enum_variant_names)]
8851 enum GeneratedField {
8852 SourceId,
8853 Cascade,
8854 }
8855 impl<'de> serde::Deserialize<'de> for GeneratedField {
8856 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8857 where
8858 D: serde::Deserializer<'de>,
8859 {
8860 struct GeneratedVisitor;
8861
8862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8863 type Value = GeneratedField;
8864
8865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8866 write!(formatter, "expected one of: {:?}", &FIELDS)
8867 }
8868
8869 #[allow(unused_variables)]
8870 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8871 where
8872 E: serde::de::Error,
8873 {
8874 match value {
8875 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8876 "cascade" => Ok(GeneratedField::Cascade),
8877 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8878 }
8879 }
8880 }
8881 deserializer.deserialize_identifier(GeneratedVisitor)
8882 }
8883 }
8884 struct GeneratedVisitor;
8885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8886 type Value = DropSourceRequest;
8887
8888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8889 formatter.write_str("struct ddl_service.DropSourceRequest")
8890 }
8891
8892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
8893 where
8894 V: serde::de::MapAccess<'de>,
8895 {
8896 let mut source_id__ = None;
8897 let mut cascade__ = None;
8898 while let Some(k) = map_.next_key()? {
8899 match k {
8900 GeneratedField::SourceId => {
8901 if source_id__.is_some() {
8902 return Err(serde::de::Error::duplicate_field("sourceId"));
8903 }
8904 source_id__ =
8905 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8906 ;
8907 }
8908 GeneratedField::Cascade => {
8909 if cascade__.is_some() {
8910 return Err(serde::de::Error::duplicate_field("cascade"));
8911 }
8912 cascade__ = Some(map_.next_value()?);
8913 }
8914 }
8915 }
8916 Ok(DropSourceRequest {
8917 source_id: source_id__.unwrap_or_default(),
8918 cascade: cascade__.unwrap_or_default(),
8919 })
8920 }
8921 }
8922 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
8923 }
8924}
8925impl serde::Serialize for DropSourceResponse {
8926 #[allow(deprecated)]
8927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8928 where
8929 S: serde::Serializer,
8930 {
8931 use serde::ser::SerializeStruct;
8932 let mut len = 0;
8933 if self.status.is_some() {
8934 len += 1;
8935 }
8936 if self.version.is_some() {
8937 len += 1;
8938 }
8939 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
8940 if let Some(v) = self.status.as_ref() {
8941 struct_ser.serialize_field("status", v)?;
8942 }
8943 if let Some(v) = self.version.as_ref() {
8944 struct_ser.serialize_field("version", v)?;
8945 }
8946 struct_ser.end()
8947 }
8948}
8949impl<'de> serde::Deserialize<'de> for DropSourceResponse {
8950 #[allow(deprecated)]
8951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8952 where
8953 D: serde::Deserializer<'de>,
8954 {
8955 const FIELDS: &[&str] = &[
8956 "status",
8957 "version",
8958 ];
8959
8960 #[allow(clippy::enum_variant_names)]
8961 enum GeneratedField {
8962 Status,
8963 Version,
8964 }
8965 impl<'de> serde::Deserialize<'de> for GeneratedField {
8966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8967 where
8968 D: serde::Deserializer<'de>,
8969 {
8970 struct GeneratedVisitor;
8971
8972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8973 type Value = GeneratedField;
8974
8975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8976 write!(formatter, "expected one of: {:?}", &FIELDS)
8977 }
8978
8979 #[allow(unused_variables)]
8980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8981 where
8982 E: serde::de::Error,
8983 {
8984 match value {
8985 "status" => Ok(GeneratedField::Status),
8986 "version" => Ok(GeneratedField::Version),
8987 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8988 }
8989 }
8990 }
8991 deserializer.deserialize_identifier(GeneratedVisitor)
8992 }
8993 }
8994 struct GeneratedVisitor;
8995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8996 type Value = DropSourceResponse;
8997
8998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8999 formatter.write_str("struct ddl_service.DropSourceResponse")
9000 }
9001
9002 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
9003 where
9004 V: serde::de::MapAccess<'de>,
9005 {
9006 let mut status__ = None;
9007 let mut version__ = None;
9008 while let Some(k) = map_.next_key()? {
9009 match k {
9010 GeneratedField::Status => {
9011 if status__.is_some() {
9012 return Err(serde::de::Error::duplicate_field("status"));
9013 }
9014 status__ = map_.next_value()?;
9015 }
9016 GeneratedField::Version => {
9017 if version__.is_some() {
9018 return Err(serde::de::Error::duplicate_field("version"));
9019 }
9020 version__ = map_.next_value()?;
9021 }
9022 }
9023 }
9024 Ok(DropSourceResponse {
9025 status: status__,
9026 version: version__,
9027 })
9028 }
9029 }
9030 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
9031 }
9032}
9033impl serde::Serialize for DropSubscriptionRequest {
9034 #[allow(deprecated)]
9035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9036 where
9037 S: serde::Serializer,
9038 {
9039 use serde::ser::SerializeStruct;
9040 let mut len = 0;
9041 if self.subscription_id != 0 {
9042 len += 1;
9043 }
9044 if self.cascade {
9045 len += 1;
9046 }
9047 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
9048 if self.subscription_id != 0 {
9049 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
9050 }
9051 if self.cascade {
9052 struct_ser.serialize_field("cascade", &self.cascade)?;
9053 }
9054 struct_ser.end()
9055 }
9056}
9057impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
9058 #[allow(deprecated)]
9059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9060 where
9061 D: serde::Deserializer<'de>,
9062 {
9063 const FIELDS: &[&str] = &[
9064 "subscription_id",
9065 "subscriptionId",
9066 "cascade",
9067 ];
9068
9069 #[allow(clippy::enum_variant_names)]
9070 enum GeneratedField {
9071 SubscriptionId,
9072 Cascade,
9073 }
9074 impl<'de> serde::Deserialize<'de> for GeneratedField {
9075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9076 where
9077 D: serde::Deserializer<'de>,
9078 {
9079 struct GeneratedVisitor;
9080
9081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9082 type Value = GeneratedField;
9083
9084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9085 write!(formatter, "expected one of: {:?}", &FIELDS)
9086 }
9087
9088 #[allow(unused_variables)]
9089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9090 where
9091 E: serde::de::Error,
9092 {
9093 match value {
9094 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
9095 "cascade" => Ok(GeneratedField::Cascade),
9096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9097 }
9098 }
9099 }
9100 deserializer.deserialize_identifier(GeneratedVisitor)
9101 }
9102 }
9103 struct GeneratedVisitor;
9104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9105 type Value = DropSubscriptionRequest;
9106
9107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9108 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
9109 }
9110
9111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
9112 where
9113 V: serde::de::MapAccess<'de>,
9114 {
9115 let mut subscription_id__ = None;
9116 let mut cascade__ = None;
9117 while let Some(k) = map_.next_key()? {
9118 match k {
9119 GeneratedField::SubscriptionId => {
9120 if subscription_id__.is_some() {
9121 return Err(serde::de::Error::duplicate_field("subscriptionId"));
9122 }
9123 subscription_id__ =
9124 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9125 ;
9126 }
9127 GeneratedField::Cascade => {
9128 if cascade__.is_some() {
9129 return Err(serde::de::Error::duplicate_field("cascade"));
9130 }
9131 cascade__ = Some(map_.next_value()?);
9132 }
9133 }
9134 }
9135 Ok(DropSubscriptionRequest {
9136 subscription_id: subscription_id__.unwrap_or_default(),
9137 cascade: cascade__.unwrap_or_default(),
9138 })
9139 }
9140 }
9141 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
9142 }
9143}
9144impl serde::Serialize for DropSubscriptionResponse {
9145 #[allow(deprecated)]
9146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9147 where
9148 S: serde::Serializer,
9149 {
9150 use serde::ser::SerializeStruct;
9151 let mut len = 0;
9152 if self.status.is_some() {
9153 len += 1;
9154 }
9155 if self.version.is_some() {
9156 len += 1;
9157 }
9158 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
9159 if let Some(v) = self.status.as_ref() {
9160 struct_ser.serialize_field("status", v)?;
9161 }
9162 if let Some(v) = self.version.as_ref() {
9163 struct_ser.serialize_field("version", v)?;
9164 }
9165 struct_ser.end()
9166 }
9167}
9168impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
9169 #[allow(deprecated)]
9170 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9171 where
9172 D: serde::Deserializer<'de>,
9173 {
9174 const FIELDS: &[&str] = &[
9175 "status",
9176 "version",
9177 ];
9178
9179 #[allow(clippy::enum_variant_names)]
9180 enum GeneratedField {
9181 Status,
9182 Version,
9183 }
9184 impl<'de> serde::Deserialize<'de> for GeneratedField {
9185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9186 where
9187 D: serde::Deserializer<'de>,
9188 {
9189 struct GeneratedVisitor;
9190
9191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9192 type Value = GeneratedField;
9193
9194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9195 write!(formatter, "expected one of: {:?}", &FIELDS)
9196 }
9197
9198 #[allow(unused_variables)]
9199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9200 where
9201 E: serde::de::Error,
9202 {
9203 match value {
9204 "status" => Ok(GeneratedField::Status),
9205 "version" => Ok(GeneratedField::Version),
9206 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9207 }
9208 }
9209 }
9210 deserializer.deserialize_identifier(GeneratedVisitor)
9211 }
9212 }
9213 struct GeneratedVisitor;
9214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9215 type Value = DropSubscriptionResponse;
9216
9217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9218 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
9219 }
9220
9221 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
9222 where
9223 V: serde::de::MapAccess<'de>,
9224 {
9225 let mut status__ = None;
9226 let mut version__ = None;
9227 while let Some(k) = map_.next_key()? {
9228 match k {
9229 GeneratedField::Status => {
9230 if status__.is_some() {
9231 return Err(serde::de::Error::duplicate_field("status"));
9232 }
9233 status__ = map_.next_value()?;
9234 }
9235 GeneratedField::Version => {
9236 if version__.is_some() {
9237 return Err(serde::de::Error::duplicate_field("version"));
9238 }
9239 version__ = map_.next_value()?;
9240 }
9241 }
9242 }
9243 Ok(DropSubscriptionResponse {
9244 status: status__,
9245 version: version__,
9246 })
9247 }
9248 }
9249 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
9250 }
9251}
9252impl serde::Serialize for DropTableRequest {
9253 #[allow(deprecated)]
9254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9255 where
9256 S: serde::Serializer,
9257 {
9258 use serde::ser::SerializeStruct;
9259 let mut len = 0;
9260 if self.table_id != 0 {
9261 len += 1;
9262 }
9263 if self.cascade {
9264 len += 1;
9265 }
9266 if self.source_id.is_some() {
9267 len += 1;
9268 }
9269 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
9270 if self.table_id != 0 {
9271 struct_ser.serialize_field("tableId", &self.table_id)?;
9272 }
9273 if self.cascade {
9274 struct_ser.serialize_field("cascade", &self.cascade)?;
9275 }
9276 if let Some(v) = self.source_id.as_ref() {
9277 match v {
9278 drop_table_request::SourceId::Id(v) => {
9279 struct_ser.serialize_field("id", v)?;
9280 }
9281 }
9282 }
9283 struct_ser.end()
9284 }
9285}
9286impl<'de> serde::Deserialize<'de> for DropTableRequest {
9287 #[allow(deprecated)]
9288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9289 where
9290 D: serde::Deserializer<'de>,
9291 {
9292 const FIELDS: &[&str] = &[
9293 "table_id",
9294 "tableId",
9295 "cascade",
9296 "id",
9297 ];
9298
9299 #[allow(clippy::enum_variant_names)]
9300 enum GeneratedField {
9301 TableId,
9302 Cascade,
9303 Id,
9304 }
9305 impl<'de> serde::Deserialize<'de> for GeneratedField {
9306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9307 where
9308 D: serde::Deserializer<'de>,
9309 {
9310 struct GeneratedVisitor;
9311
9312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9313 type Value = GeneratedField;
9314
9315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9316 write!(formatter, "expected one of: {:?}", &FIELDS)
9317 }
9318
9319 #[allow(unused_variables)]
9320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9321 where
9322 E: serde::de::Error,
9323 {
9324 match value {
9325 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9326 "cascade" => Ok(GeneratedField::Cascade),
9327 "id" => Ok(GeneratedField::Id),
9328 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9329 }
9330 }
9331 }
9332 deserializer.deserialize_identifier(GeneratedVisitor)
9333 }
9334 }
9335 struct GeneratedVisitor;
9336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9337 type Value = DropTableRequest;
9338
9339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9340 formatter.write_str("struct ddl_service.DropTableRequest")
9341 }
9342
9343 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
9344 where
9345 V: serde::de::MapAccess<'de>,
9346 {
9347 let mut table_id__ = None;
9348 let mut cascade__ = None;
9349 let mut source_id__ = None;
9350 while let Some(k) = map_.next_key()? {
9351 match k {
9352 GeneratedField::TableId => {
9353 if table_id__.is_some() {
9354 return Err(serde::de::Error::duplicate_field("tableId"));
9355 }
9356 table_id__ =
9357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9358 ;
9359 }
9360 GeneratedField::Cascade => {
9361 if cascade__.is_some() {
9362 return Err(serde::de::Error::duplicate_field("cascade"));
9363 }
9364 cascade__ = Some(map_.next_value()?);
9365 }
9366 GeneratedField::Id => {
9367 if source_id__.is_some() {
9368 return Err(serde::de::Error::duplicate_field("id"));
9369 }
9370 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
9371 }
9372 }
9373 }
9374 Ok(DropTableRequest {
9375 table_id: table_id__.unwrap_or_default(),
9376 cascade: cascade__.unwrap_or_default(),
9377 source_id: source_id__,
9378 })
9379 }
9380 }
9381 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
9382 }
9383}
9384impl serde::Serialize for DropTableResponse {
9385 #[allow(deprecated)]
9386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9387 where
9388 S: serde::Serializer,
9389 {
9390 use serde::ser::SerializeStruct;
9391 let mut len = 0;
9392 if self.status.is_some() {
9393 len += 1;
9394 }
9395 if self.version.is_some() {
9396 len += 1;
9397 }
9398 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
9399 if let Some(v) = self.status.as_ref() {
9400 struct_ser.serialize_field("status", v)?;
9401 }
9402 if let Some(v) = self.version.as_ref() {
9403 struct_ser.serialize_field("version", v)?;
9404 }
9405 struct_ser.end()
9406 }
9407}
9408impl<'de> serde::Deserialize<'de> for DropTableResponse {
9409 #[allow(deprecated)]
9410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9411 where
9412 D: serde::Deserializer<'de>,
9413 {
9414 const FIELDS: &[&str] = &[
9415 "status",
9416 "version",
9417 ];
9418
9419 #[allow(clippy::enum_variant_names)]
9420 enum GeneratedField {
9421 Status,
9422 Version,
9423 }
9424 impl<'de> serde::Deserialize<'de> for GeneratedField {
9425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9426 where
9427 D: serde::Deserializer<'de>,
9428 {
9429 struct GeneratedVisitor;
9430
9431 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9432 type Value = GeneratedField;
9433
9434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9435 write!(formatter, "expected one of: {:?}", &FIELDS)
9436 }
9437
9438 #[allow(unused_variables)]
9439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9440 where
9441 E: serde::de::Error,
9442 {
9443 match value {
9444 "status" => Ok(GeneratedField::Status),
9445 "version" => Ok(GeneratedField::Version),
9446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9447 }
9448 }
9449 }
9450 deserializer.deserialize_identifier(GeneratedVisitor)
9451 }
9452 }
9453 struct GeneratedVisitor;
9454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9455 type Value = DropTableResponse;
9456
9457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9458 formatter.write_str("struct ddl_service.DropTableResponse")
9459 }
9460
9461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
9462 where
9463 V: serde::de::MapAccess<'de>,
9464 {
9465 let mut status__ = None;
9466 let mut version__ = None;
9467 while let Some(k) = map_.next_key()? {
9468 match k {
9469 GeneratedField::Status => {
9470 if status__.is_some() {
9471 return Err(serde::de::Error::duplicate_field("status"));
9472 }
9473 status__ = map_.next_value()?;
9474 }
9475 GeneratedField::Version => {
9476 if version__.is_some() {
9477 return Err(serde::de::Error::duplicate_field("version"));
9478 }
9479 version__ = map_.next_value()?;
9480 }
9481 }
9482 }
9483 Ok(DropTableResponse {
9484 status: status__,
9485 version: version__,
9486 })
9487 }
9488 }
9489 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
9490 }
9491}
9492impl serde::Serialize for DropViewRequest {
9493 #[allow(deprecated)]
9494 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9495 where
9496 S: serde::Serializer,
9497 {
9498 use serde::ser::SerializeStruct;
9499 let mut len = 0;
9500 if self.view_id != 0 {
9501 len += 1;
9502 }
9503 if self.cascade {
9504 len += 1;
9505 }
9506 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
9507 if self.view_id != 0 {
9508 struct_ser.serialize_field("viewId", &self.view_id)?;
9509 }
9510 if self.cascade {
9511 struct_ser.serialize_field("cascade", &self.cascade)?;
9512 }
9513 struct_ser.end()
9514 }
9515}
9516impl<'de> serde::Deserialize<'de> for DropViewRequest {
9517 #[allow(deprecated)]
9518 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9519 where
9520 D: serde::Deserializer<'de>,
9521 {
9522 const FIELDS: &[&str] = &[
9523 "view_id",
9524 "viewId",
9525 "cascade",
9526 ];
9527
9528 #[allow(clippy::enum_variant_names)]
9529 enum GeneratedField {
9530 ViewId,
9531 Cascade,
9532 }
9533 impl<'de> serde::Deserialize<'de> for GeneratedField {
9534 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9535 where
9536 D: serde::Deserializer<'de>,
9537 {
9538 struct GeneratedVisitor;
9539
9540 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9541 type Value = GeneratedField;
9542
9543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9544 write!(formatter, "expected one of: {:?}", &FIELDS)
9545 }
9546
9547 #[allow(unused_variables)]
9548 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9549 where
9550 E: serde::de::Error,
9551 {
9552 match value {
9553 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
9554 "cascade" => Ok(GeneratedField::Cascade),
9555 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9556 }
9557 }
9558 }
9559 deserializer.deserialize_identifier(GeneratedVisitor)
9560 }
9561 }
9562 struct GeneratedVisitor;
9563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9564 type Value = DropViewRequest;
9565
9566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9567 formatter.write_str("struct ddl_service.DropViewRequest")
9568 }
9569
9570 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
9571 where
9572 V: serde::de::MapAccess<'de>,
9573 {
9574 let mut view_id__ = None;
9575 let mut cascade__ = None;
9576 while let Some(k) = map_.next_key()? {
9577 match k {
9578 GeneratedField::ViewId => {
9579 if view_id__.is_some() {
9580 return Err(serde::de::Error::duplicate_field("viewId"));
9581 }
9582 view_id__ =
9583 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9584 ;
9585 }
9586 GeneratedField::Cascade => {
9587 if cascade__.is_some() {
9588 return Err(serde::de::Error::duplicate_field("cascade"));
9589 }
9590 cascade__ = Some(map_.next_value()?);
9591 }
9592 }
9593 }
9594 Ok(DropViewRequest {
9595 view_id: view_id__.unwrap_or_default(),
9596 cascade: cascade__.unwrap_or_default(),
9597 })
9598 }
9599 }
9600 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
9601 }
9602}
9603impl serde::Serialize for DropViewResponse {
9604 #[allow(deprecated)]
9605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9606 where
9607 S: serde::Serializer,
9608 {
9609 use serde::ser::SerializeStruct;
9610 let mut len = 0;
9611 if self.status.is_some() {
9612 len += 1;
9613 }
9614 if self.version.is_some() {
9615 len += 1;
9616 }
9617 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
9618 if let Some(v) = self.status.as_ref() {
9619 struct_ser.serialize_field("status", v)?;
9620 }
9621 if let Some(v) = self.version.as_ref() {
9622 struct_ser.serialize_field("version", v)?;
9623 }
9624 struct_ser.end()
9625 }
9626}
9627impl<'de> serde::Deserialize<'de> for DropViewResponse {
9628 #[allow(deprecated)]
9629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9630 where
9631 D: serde::Deserializer<'de>,
9632 {
9633 const FIELDS: &[&str] = &[
9634 "status",
9635 "version",
9636 ];
9637
9638 #[allow(clippy::enum_variant_names)]
9639 enum GeneratedField {
9640 Status,
9641 Version,
9642 }
9643 impl<'de> serde::Deserialize<'de> for GeneratedField {
9644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9645 where
9646 D: serde::Deserializer<'de>,
9647 {
9648 struct GeneratedVisitor;
9649
9650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9651 type Value = GeneratedField;
9652
9653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9654 write!(formatter, "expected one of: {:?}", &FIELDS)
9655 }
9656
9657 #[allow(unused_variables)]
9658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9659 where
9660 E: serde::de::Error,
9661 {
9662 match value {
9663 "status" => Ok(GeneratedField::Status),
9664 "version" => Ok(GeneratedField::Version),
9665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9666 }
9667 }
9668 }
9669 deserializer.deserialize_identifier(GeneratedVisitor)
9670 }
9671 }
9672 struct GeneratedVisitor;
9673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9674 type Value = DropViewResponse;
9675
9676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9677 formatter.write_str("struct ddl_service.DropViewResponse")
9678 }
9679
9680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
9681 where
9682 V: serde::de::MapAccess<'de>,
9683 {
9684 let mut status__ = None;
9685 let mut version__ = None;
9686 while let Some(k) = map_.next_key()? {
9687 match k {
9688 GeneratedField::Status => {
9689 if status__.is_some() {
9690 return Err(serde::de::Error::duplicate_field("status"));
9691 }
9692 status__ = map_.next_value()?;
9693 }
9694 GeneratedField::Version => {
9695 if version__.is_some() {
9696 return Err(serde::de::Error::duplicate_field("version"));
9697 }
9698 version__ = map_.next_value()?;
9699 }
9700 }
9701 }
9702 Ok(DropViewResponse {
9703 status: status__,
9704 version: version__,
9705 })
9706 }
9707 }
9708 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
9709 }
9710}
9711impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
9712 #[allow(deprecated)]
9713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9714 where
9715 S: serde::Serializer,
9716 {
9717 use serde::ser::SerializeStruct;
9718 let mut len = 0;
9719 if self.sink_id != 0 {
9720 len += 1;
9721 }
9722 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
9723 if self.sink_id != 0 {
9724 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9725 }
9726 struct_ser.end()
9727 }
9728}
9729impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
9730 #[allow(deprecated)]
9731 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9732 where
9733 D: serde::Deserializer<'de>,
9734 {
9735 const FIELDS: &[&str] = &[
9736 "sink_id",
9737 "sinkId",
9738 ];
9739
9740 #[allow(clippy::enum_variant_names)]
9741 enum GeneratedField {
9742 SinkId,
9743 }
9744 impl<'de> serde::Deserialize<'de> for GeneratedField {
9745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9746 where
9747 D: serde::Deserializer<'de>,
9748 {
9749 struct GeneratedVisitor;
9750
9751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9752 type Value = GeneratedField;
9753
9754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9755 write!(formatter, "expected one of: {:?}", &FIELDS)
9756 }
9757
9758 #[allow(unused_variables)]
9759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9760 where
9761 E: serde::de::Error,
9762 {
9763 match value {
9764 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9766 }
9767 }
9768 }
9769 deserializer.deserialize_identifier(GeneratedVisitor)
9770 }
9771 }
9772 struct GeneratedVisitor;
9773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9774 type Value = ExpireIcebergTableSnapshotsRequest;
9775
9776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9777 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
9778 }
9779
9780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
9781 where
9782 V: serde::de::MapAccess<'de>,
9783 {
9784 let mut sink_id__ = None;
9785 while let Some(k) = map_.next_key()? {
9786 match k {
9787 GeneratedField::SinkId => {
9788 if sink_id__.is_some() {
9789 return Err(serde::de::Error::duplicate_field("sinkId"));
9790 }
9791 sink_id__ =
9792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9793 ;
9794 }
9795 }
9796 }
9797 Ok(ExpireIcebergTableSnapshotsRequest {
9798 sink_id: sink_id__.unwrap_or_default(),
9799 })
9800 }
9801 }
9802 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
9803 }
9804}
9805impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
9806 #[allow(deprecated)]
9807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9808 where
9809 S: serde::Serializer,
9810 {
9811 use serde::ser::SerializeStruct;
9812 let mut len = 0;
9813 if self.status.is_some() {
9814 len += 1;
9815 }
9816 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
9817 if let Some(v) = self.status.as_ref() {
9818 struct_ser.serialize_field("status", v)?;
9819 }
9820 struct_ser.end()
9821 }
9822}
9823impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
9824 #[allow(deprecated)]
9825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9826 where
9827 D: serde::Deserializer<'de>,
9828 {
9829 const FIELDS: &[&str] = &[
9830 "status",
9831 ];
9832
9833 #[allow(clippy::enum_variant_names)]
9834 enum GeneratedField {
9835 Status,
9836 }
9837 impl<'de> serde::Deserialize<'de> for GeneratedField {
9838 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9839 where
9840 D: serde::Deserializer<'de>,
9841 {
9842 struct GeneratedVisitor;
9843
9844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9845 type Value = GeneratedField;
9846
9847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9848 write!(formatter, "expected one of: {:?}", &FIELDS)
9849 }
9850
9851 #[allow(unused_variables)]
9852 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9853 where
9854 E: serde::de::Error,
9855 {
9856 match value {
9857 "status" => Ok(GeneratedField::Status),
9858 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9859 }
9860 }
9861 }
9862 deserializer.deserialize_identifier(GeneratedVisitor)
9863 }
9864 }
9865 struct GeneratedVisitor;
9866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9867 type Value = ExpireIcebergTableSnapshotsResponse;
9868
9869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9870 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
9871 }
9872
9873 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
9874 where
9875 V: serde::de::MapAccess<'de>,
9876 {
9877 let mut status__ = None;
9878 while let Some(k) = map_.next_key()? {
9879 match k {
9880 GeneratedField::Status => {
9881 if status__.is_some() {
9882 return Err(serde::de::Error::duplicate_field("status"));
9883 }
9884 status__ = map_.next_value()?;
9885 }
9886 }
9887 }
9888 Ok(ExpireIcebergTableSnapshotsResponse {
9889 status: status__,
9890 })
9891 }
9892 }
9893 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
9894 }
9895}
9896impl serde::Serialize for GetDdlProgressRequest {
9897 #[allow(deprecated)]
9898 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9899 where
9900 S: serde::Serializer,
9901 {
9902 use serde::ser::SerializeStruct;
9903 let len = 0;
9904 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
9905 struct_ser.end()
9906 }
9907}
9908impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
9909 #[allow(deprecated)]
9910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9911 where
9912 D: serde::Deserializer<'de>,
9913 {
9914 const FIELDS: &[&str] = &[
9915 ];
9916
9917 #[allow(clippy::enum_variant_names)]
9918 enum GeneratedField {
9919 }
9920 impl<'de> serde::Deserialize<'de> for GeneratedField {
9921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9922 where
9923 D: serde::Deserializer<'de>,
9924 {
9925 struct GeneratedVisitor;
9926
9927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9928 type Value = GeneratedField;
9929
9930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9931 write!(formatter, "expected one of: {:?}", &FIELDS)
9932 }
9933
9934 #[allow(unused_variables)]
9935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9936 where
9937 E: serde::de::Error,
9938 {
9939 Err(serde::de::Error::unknown_field(value, FIELDS))
9940 }
9941 }
9942 deserializer.deserialize_identifier(GeneratedVisitor)
9943 }
9944 }
9945 struct GeneratedVisitor;
9946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9947 type Value = GetDdlProgressRequest;
9948
9949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9950 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
9951 }
9952
9953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
9954 where
9955 V: serde::de::MapAccess<'de>,
9956 {
9957 while map_.next_key::<GeneratedField>()?.is_some() {
9958 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9959 }
9960 Ok(GetDdlProgressRequest {
9961 })
9962 }
9963 }
9964 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
9965 }
9966}
9967impl serde::Serialize for GetDdlProgressResponse {
9968 #[allow(deprecated)]
9969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9970 where
9971 S: serde::Serializer,
9972 {
9973 use serde::ser::SerializeStruct;
9974 let mut len = 0;
9975 if !self.ddl_progress.is_empty() {
9976 len += 1;
9977 }
9978 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
9979 if !self.ddl_progress.is_empty() {
9980 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
9981 }
9982 struct_ser.end()
9983 }
9984}
9985impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
9986 #[allow(deprecated)]
9987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9988 where
9989 D: serde::Deserializer<'de>,
9990 {
9991 const FIELDS: &[&str] = &[
9992 "ddl_progress",
9993 "ddlProgress",
9994 ];
9995
9996 #[allow(clippy::enum_variant_names)]
9997 enum GeneratedField {
9998 DdlProgress,
9999 }
10000 impl<'de> serde::Deserialize<'de> for GeneratedField {
10001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10002 where
10003 D: serde::Deserializer<'de>,
10004 {
10005 struct GeneratedVisitor;
10006
10007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10008 type Value = GeneratedField;
10009
10010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10011 write!(formatter, "expected one of: {:?}", &FIELDS)
10012 }
10013
10014 #[allow(unused_variables)]
10015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10016 where
10017 E: serde::de::Error,
10018 {
10019 match value {
10020 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
10021 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10022 }
10023 }
10024 }
10025 deserializer.deserialize_identifier(GeneratedVisitor)
10026 }
10027 }
10028 struct GeneratedVisitor;
10029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10030 type Value = GetDdlProgressResponse;
10031
10032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10033 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
10034 }
10035
10036 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
10037 where
10038 V: serde::de::MapAccess<'de>,
10039 {
10040 let mut ddl_progress__ = None;
10041 while let Some(k) = map_.next_key()? {
10042 match k {
10043 GeneratedField::DdlProgress => {
10044 if ddl_progress__.is_some() {
10045 return Err(serde::de::Error::duplicate_field("ddlProgress"));
10046 }
10047 ddl_progress__ = Some(map_.next_value()?);
10048 }
10049 }
10050 }
10051 Ok(GetDdlProgressResponse {
10052 ddl_progress: ddl_progress__.unwrap_or_default(),
10053 })
10054 }
10055 }
10056 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
10057 }
10058}
10059impl serde::Serialize for GetTableRequest {
10060 #[allow(deprecated)]
10061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10062 where
10063 S: serde::Serializer,
10064 {
10065 use serde::ser::SerializeStruct;
10066 let mut len = 0;
10067 if !self.database_name.is_empty() {
10068 len += 1;
10069 }
10070 if !self.table_name.is_empty() {
10071 len += 1;
10072 }
10073 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
10074 if !self.database_name.is_empty() {
10075 struct_ser.serialize_field("databaseName", &self.database_name)?;
10076 }
10077 if !self.table_name.is_empty() {
10078 struct_ser.serialize_field("tableName", &self.table_name)?;
10079 }
10080 struct_ser.end()
10081 }
10082}
10083impl<'de> serde::Deserialize<'de> for GetTableRequest {
10084 #[allow(deprecated)]
10085 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10086 where
10087 D: serde::Deserializer<'de>,
10088 {
10089 const FIELDS: &[&str] = &[
10090 "database_name",
10091 "databaseName",
10092 "table_name",
10093 "tableName",
10094 ];
10095
10096 #[allow(clippy::enum_variant_names)]
10097 enum GeneratedField {
10098 DatabaseName,
10099 TableName,
10100 }
10101 impl<'de> serde::Deserialize<'de> for GeneratedField {
10102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10103 where
10104 D: serde::Deserializer<'de>,
10105 {
10106 struct GeneratedVisitor;
10107
10108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10109 type Value = GeneratedField;
10110
10111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10112 write!(formatter, "expected one of: {:?}", &FIELDS)
10113 }
10114
10115 #[allow(unused_variables)]
10116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10117 where
10118 E: serde::de::Error,
10119 {
10120 match value {
10121 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
10122 "tableName" | "table_name" => Ok(GeneratedField::TableName),
10123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10124 }
10125 }
10126 }
10127 deserializer.deserialize_identifier(GeneratedVisitor)
10128 }
10129 }
10130 struct GeneratedVisitor;
10131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10132 type Value = GetTableRequest;
10133
10134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10135 formatter.write_str("struct ddl_service.GetTableRequest")
10136 }
10137
10138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
10139 where
10140 V: serde::de::MapAccess<'de>,
10141 {
10142 let mut database_name__ = None;
10143 let mut table_name__ = None;
10144 while let Some(k) = map_.next_key()? {
10145 match k {
10146 GeneratedField::DatabaseName => {
10147 if database_name__.is_some() {
10148 return Err(serde::de::Error::duplicate_field("databaseName"));
10149 }
10150 database_name__ = Some(map_.next_value()?);
10151 }
10152 GeneratedField::TableName => {
10153 if table_name__.is_some() {
10154 return Err(serde::de::Error::duplicate_field("tableName"));
10155 }
10156 table_name__ = Some(map_.next_value()?);
10157 }
10158 }
10159 }
10160 Ok(GetTableRequest {
10161 database_name: database_name__.unwrap_or_default(),
10162 table_name: table_name__.unwrap_or_default(),
10163 })
10164 }
10165 }
10166 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
10167 }
10168}
10169impl serde::Serialize for GetTableResponse {
10170 #[allow(deprecated)]
10171 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10172 where
10173 S: serde::Serializer,
10174 {
10175 use serde::ser::SerializeStruct;
10176 let mut len = 0;
10177 if self.table.is_some() {
10178 len += 1;
10179 }
10180 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
10181 if let Some(v) = self.table.as_ref() {
10182 struct_ser.serialize_field("table", v)?;
10183 }
10184 struct_ser.end()
10185 }
10186}
10187impl<'de> serde::Deserialize<'de> for GetTableResponse {
10188 #[allow(deprecated)]
10189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10190 where
10191 D: serde::Deserializer<'de>,
10192 {
10193 const FIELDS: &[&str] = &[
10194 "table",
10195 ];
10196
10197 #[allow(clippy::enum_variant_names)]
10198 enum GeneratedField {
10199 Table,
10200 }
10201 impl<'de> serde::Deserialize<'de> for GeneratedField {
10202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10203 where
10204 D: serde::Deserializer<'de>,
10205 {
10206 struct GeneratedVisitor;
10207
10208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10209 type Value = GeneratedField;
10210
10211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10212 write!(formatter, "expected one of: {:?}", &FIELDS)
10213 }
10214
10215 #[allow(unused_variables)]
10216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10217 where
10218 E: serde::de::Error,
10219 {
10220 match value {
10221 "table" => Ok(GeneratedField::Table),
10222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10223 }
10224 }
10225 }
10226 deserializer.deserialize_identifier(GeneratedVisitor)
10227 }
10228 }
10229 struct GeneratedVisitor;
10230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10231 type Value = GetTableResponse;
10232
10233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10234 formatter.write_str("struct ddl_service.GetTableResponse")
10235 }
10236
10237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
10238 where
10239 V: serde::de::MapAccess<'de>,
10240 {
10241 let mut table__ = None;
10242 while let Some(k) = map_.next_key()? {
10243 match k {
10244 GeneratedField::Table => {
10245 if table__.is_some() {
10246 return Err(serde::de::Error::duplicate_field("table"));
10247 }
10248 table__ = map_.next_value()?;
10249 }
10250 }
10251 }
10252 Ok(GetTableResponse {
10253 table: table__,
10254 })
10255 }
10256 }
10257 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
10258 }
10259}
10260impl serde::Serialize for GetTablesRequest {
10261 #[allow(deprecated)]
10262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10263 where
10264 S: serde::Serializer,
10265 {
10266 use serde::ser::SerializeStruct;
10267 let mut len = 0;
10268 if !self.table_ids.is_empty() {
10269 len += 1;
10270 }
10271 if self.include_dropped_tables {
10272 len += 1;
10273 }
10274 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
10275 if !self.table_ids.is_empty() {
10276 struct_ser.serialize_field("tableIds", &self.table_ids)?;
10277 }
10278 if self.include_dropped_tables {
10279 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
10280 }
10281 struct_ser.end()
10282 }
10283}
10284impl<'de> serde::Deserialize<'de> for GetTablesRequest {
10285 #[allow(deprecated)]
10286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10287 where
10288 D: serde::Deserializer<'de>,
10289 {
10290 const FIELDS: &[&str] = &[
10291 "table_ids",
10292 "tableIds",
10293 "include_dropped_tables",
10294 "includeDroppedTables",
10295 ];
10296
10297 #[allow(clippy::enum_variant_names)]
10298 enum GeneratedField {
10299 TableIds,
10300 IncludeDroppedTables,
10301 }
10302 impl<'de> serde::Deserialize<'de> for GeneratedField {
10303 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10304 where
10305 D: serde::Deserializer<'de>,
10306 {
10307 struct GeneratedVisitor;
10308
10309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10310 type Value = GeneratedField;
10311
10312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10313 write!(formatter, "expected one of: {:?}", &FIELDS)
10314 }
10315
10316 #[allow(unused_variables)]
10317 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10318 where
10319 E: serde::de::Error,
10320 {
10321 match value {
10322 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10323 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
10324 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10325 }
10326 }
10327 }
10328 deserializer.deserialize_identifier(GeneratedVisitor)
10329 }
10330 }
10331 struct GeneratedVisitor;
10332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10333 type Value = GetTablesRequest;
10334
10335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10336 formatter.write_str("struct ddl_service.GetTablesRequest")
10337 }
10338
10339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
10340 where
10341 V: serde::de::MapAccess<'de>,
10342 {
10343 let mut table_ids__ = None;
10344 let mut include_dropped_tables__ = None;
10345 while let Some(k) = map_.next_key()? {
10346 match k {
10347 GeneratedField::TableIds => {
10348 if table_ids__.is_some() {
10349 return Err(serde::de::Error::duplicate_field("tableIds"));
10350 }
10351 table_ids__ =
10352 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10353 .into_iter().map(|x| x.0).collect())
10354 ;
10355 }
10356 GeneratedField::IncludeDroppedTables => {
10357 if include_dropped_tables__.is_some() {
10358 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
10359 }
10360 include_dropped_tables__ = Some(map_.next_value()?);
10361 }
10362 }
10363 }
10364 Ok(GetTablesRequest {
10365 table_ids: table_ids__.unwrap_or_default(),
10366 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
10367 })
10368 }
10369 }
10370 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
10371 }
10372}
10373impl serde::Serialize for GetTablesResponse {
10374 #[allow(deprecated)]
10375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10376 where
10377 S: serde::Serializer,
10378 {
10379 use serde::ser::SerializeStruct;
10380 let mut len = 0;
10381 if !self.tables.is_empty() {
10382 len += 1;
10383 }
10384 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
10385 if !self.tables.is_empty() {
10386 struct_ser.serialize_field("tables", &self.tables)?;
10387 }
10388 struct_ser.end()
10389 }
10390}
10391impl<'de> serde::Deserialize<'de> for GetTablesResponse {
10392 #[allow(deprecated)]
10393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10394 where
10395 D: serde::Deserializer<'de>,
10396 {
10397 const FIELDS: &[&str] = &[
10398 "tables",
10399 ];
10400
10401 #[allow(clippy::enum_variant_names)]
10402 enum GeneratedField {
10403 Tables,
10404 }
10405 impl<'de> serde::Deserialize<'de> for GeneratedField {
10406 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10407 where
10408 D: serde::Deserializer<'de>,
10409 {
10410 struct GeneratedVisitor;
10411
10412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10413 type Value = GeneratedField;
10414
10415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10416 write!(formatter, "expected one of: {:?}", &FIELDS)
10417 }
10418
10419 #[allow(unused_variables)]
10420 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10421 where
10422 E: serde::de::Error,
10423 {
10424 match value {
10425 "tables" => Ok(GeneratedField::Tables),
10426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10427 }
10428 }
10429 }
10430 deserializer.deserialize_identifier(GeneratedVisitor)
10431 }
10432 }
10433 struct GeneratedVisitor;
10434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10435 type Value = GetTablesResponse;
10436
10437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10438 formatter.write_str("struct ddl_service.GetTablesResponse")
10439 }
10440
10441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
10442 where
10443 V: serde::de::MapAccess<'de>,
10444 {
10445 let mut tables__ = None;
10446 while let Some(k) = map_.next_key()? {
10447 match k {
10448 GeneratedField::Tables => {
10449 if tables__.is_some() {
10450 return Err(serde::de::Error::duplicate_field("tables"));
10451 }
10452 tables__ = Some(
10453 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10454 .into_iter().map(|(k,v)| (k.0, v)).collect()
10455 );
10456 }
10457 }
10458 }
10459 Ok(GetTablesResponse {
10460 tables: tables__.unwrap_or_default(),
10461 })
10462 }
10463 }
10464 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
10465 }
10466}
10467impl serde::Serialize for ListConnectionsRequest {
10468 #[allow(deprecated)]
10469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10470 where
10471 S: serde::Serializer,
10472 {
10473 use serde::ser::SerializeStruct;
10474 let len = 0;
10475 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
10476 struct_ser.end()
10477 }
10478}
10479impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
10480 #[allow(deprecated)]
10481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10482 where
10483 D: serde::Deserializer<'de>,
10484 {
10485 const FIELDS: &[&str] = &[
10486 ];
10487
10488 #[allow(clippy::enum_variant_names)]
10489 enum GeneratedField {
10490 }
10491 impl<'de> serde::Deserialize<'de> for GeneratedField {
10492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10493 where
10494 D: serde::Deserializer<'de>,
10495 {
10496 struct GeneratedVisitor;
10497
10498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10499 type Value = GeneratedField;
10500
10501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10502 write!(formatter, "expected one of: {:?}", &FIELDS)
10503 }
10504
10505 #[allow(unused_variables)]
10506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10507 where
10508 E: serde::de::Error,
10509 {
10510 Err(serde::de::Error::unknown_field(value, FIELDS))
10511 }
10512 }
10513 deserializer.deserialize_identifier(GeneratedVisitor)
10514 }
10515 }
10516 struct GeneratedVisitor;
10517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10518 type Value = ListConnectionsRequest;
10519
10520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10521 formatter.write_str("struct ddl_service.ListConnectionsRequest")
10522 }
10523
10524 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
10525 where
10526 V: serde::de::MapAccess<'de>,
10527 {
10528 while map_.next_key::<GeneratedField>()?.is_some() {
10529 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10530 }
10531 Ok(ListConnectionsRequest {
10532 })
10533 }
10534 }
10535 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
10536 }
10537}
10538impl serde::Serialize for ListConnectionsResponse {
10539 #[allow(deprecated)]
10540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10541 where
10542 S: serde::Serializer,
10543 {
10544 use serde::ser::SerializeStruct;
10545 let mut len = 0;
10546 if !self.connections.is_empty() {
10547 len += 1;
10548 }
10549 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
10550 if !self.connections.is_empty() {
10551 struct_ser.serialize_field("connections", &self.connections)?;
10552 }
10553 struct_ser.end()
10554 }
10555}
10556impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
10557 #[allow(deprecated)]
10558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10559 where
10560 D: serde::Deserializer<'de>,
10561 {
10562 const FIELDS: &[&str] = &[
10563 "connections",
10564 ];
10565
10566 #[allow(clippy::enum_variant_names)]
10567 enum GeneratedField {
10568 Connections,
10569 }
10570 impl<'de> serde::Deserialize<'de> for GeneratedField {
10571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10572 where
10573 D: serde::Deserializer<'de>,
10574 {
10575 struct GeneratedVisitor;
10576
10577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10578 type Value = GeneratedField;
10579
10580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10581 write!(formatter, "expected one of: {:?}", &FIELDS)
10582 }
10583
10584 #[allow(unused_variables)]
10585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10586 where
10587 E: serde::de::Error,
10588 {
10589 match value {
10590 "connections" => Ok(GeneratedField::Connections),
10591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10592 }
10593 }
10594 }
10595 deserializer.deserialize_identifier(GeneratedVisitor)
10596 }
10597 }
10598 struct GeneratedVisitor;
10599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10600 type Value = ListConnectionsResponse;
10601
10602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10603 formatter.write_str("struct ddl_service.ListConnectionsResponse")
10604 }
10605
10606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
10607 where
10608 V: serde::de::MapAccess<'de>,
10609 {
10610 let mut connections__ = None;
10611 while let Some(k) = map_.next_key()? {
10612 match k {
10613 GeneratedField::Connections => {
10614 if connections__.is_some() {
10615 return Err(serde::de::Error::duplicate_field("connections"));
10616 }
10617 connections__ = Some(map_.next_value()?);
10618 }
10619 }
10620 }
10621 Ok(ListConnectionsResponse {
10622 connections: connections__.unwrap_or_default(),
10623 })
10624 }
10625 }
10626 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
10627 }
10628}
10629impl serde::Serialize for ReplaceJobPlan {
10630 #[allow(deprecated)]
10631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10632 where
10633 S: serde::Serializer,
10634 {
10635 use serde::ser::SerializeStruct;
10636 let mut len = 0;
10637 if self.fragment_graph.is_some() {
10638 len += 1;
10639 }
10640 if self.replace_job.is_some() {
10641 len += 1;
10642 }
10643 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
10644 if let Some(v) = self.fragment_graph.as_ref() {
10645 struct_ser.serialize_field("fragmentGraph", v)?;
10646 }
10647 if let Some(v) = self.replace_job.as_ref() {
10648 match v {
10649 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
10650 struct_ser.serialize_field("replaceTable", v)?;
10651 }
10652 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
10653 struct_ser.serialize_field("replaceSource", v)?;
10654 }
10655 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
10656 struct_ser.serialize_field("replaceMaterializedView", v)?;
10657 }
10658 }
10659 }
10660 struct_ser.end()
10661 }
10662}
10663impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
10664 #[allow(deprecated)]
10665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10666 where
10667 D: serde::Deserializer<'de>,
10668 {
10669 const FIELDS: &[&str] = &[
10670 "fragment_graph",
10671 "fragmentGraph",
10672 "replace_table",
10673 "replaceTable",
10674 "replace_source",
10675 "replaceSource",
10676 "replace_materialized_view",
10677 "replaceMaterializedView",
10678 ];
10679
10680 #[allow(clippy::enum_variant_names)]
10681 enum GeneratedField {
10682 FragmentGraph,
10683 ReplaceTable,
10684 ReplaceSource,
10685 ReplaceMaterializedView,
10686 }
10687 impl<'de> serde::Deserialize<'de> for GeneratedField {
10688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10689 where
10690 D: serde::Deserializer<'de>,
10691 {
10692 struct GeneratedVisitor;
10693
10694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10695 type Value = GeneratedField;
10696
10697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10698 write!(formatter, "expected one of: {:?}", &FIELDS)
10699 }
10700
10701 #[allow(unused_variables)]
10702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10703 where
10704 E: serde::de::Error,
10705 {
10706 match value {
10707 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
10708 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
10709 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
10710 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
10711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10712 }
10713 }
10714 }
10715 deserializer.deserialize_identifier(GeneratedVisitor)
10716 }
10717 }
10718 struct GeneratedVisitor;
10719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10720 type Value = ReplaceJobPlan;
10721
10722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10723 formatter.write_str("struct ddl_service.ReplaceJobPlan")
10724 }
10725
10726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
10727 where
10728 V: serde::de::MapAccess<'de>,
10729 {
10730 let mut fragment_graph__ = None;
10731 let mut replace_job__ = None;
10732 while let Some(k) = map_.next_key()? {
10733 match k {
10734 GeneratedField::FragmentGraph => {
10735 if fragment_graph__.is_some() {
10736 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
10737 }
10738 fragment_graph__ = map_.next_value()?;
10739 }
10740 GeneratedField::ReplaceTable => {
10741 if replace_job__.is_some() {
10742 return Err(serde::de::Error::duplicate_field("replaceTable"));
10743 }
10744 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
10745;
10746 }
10747 GeneratedField::ReplaceSource => {
10748 if replace_job__.is_some() {
10749 return Err(serde::de::Error::duplicate_field("replaceSource"));
10750 }
10751 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
10752;
10753 }
10754 GeneratedField::ReplaceMaterializedView => {
10755 if replace_job__.is_some() {
10756 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
10757 }
10758 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
10759;
10760 }
10761 }
10762 }
10763 Ok(ReplaceJobPlan {
10764 fragment_graph: fragment_graph__,
10765 replace_job: replace_job__,
10766 })
10767 }
10768 }
10769 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
10770 }
10771}
10772impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
10773 #[allow(deprecated)]
10774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10775 where
10776 S: serde::Serializer,
10777 {
10778 use serde::ser::SerializeStruct;
10779 let mut len = 0;
10780 if self.table.is_some() {
10781 len += 1;
10782 }
10783 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
10784 if let Some(v) = self.table.as_ref() {
10785 struct_ser.serialize_field("table", v)?;
10786 }
10787 struct_ser.end()
10788 }
10789}
10790impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
10791 #[allow(deprecated)]
10792 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10793 where
10794 D: serde::Deserializer<'de>,
10795 {
10796 const FIELDS: &[&str] = &[
10797 "table",
10798 ];
10799
10800 #[allow(clippy::enum_variant_names)]
10801 enum GeneratedField {
10802 Table,
10803 }
10804 impl<'de> serde::Deserialize<'de> for GeneratedField {
10805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10806 where
10807 D: serde::Deserializer<'de>,
10808 {
10809 struct GeneratedVisitor;
10810
10811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10812 type Value = GeneratedField;
10813
10814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10815 write!(formatter, "expected one of: {:?}", &FIELDS)
10816 }
10817
10818 #[allow(unused_variables)]
10819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10820 where
10821 E: serde::de::Error,
10822 {
10823 match value {
10824 "table" => Ok(GeneratedField::Table),
10825 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10826 }
10827 }
10828 }
10829 deserializer.deserialize_identifier(GeneratedVisitor)
10830 }
10831 }
10832 struct GeneratedVisitor;
10833 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10834 type Value = replace_job_plan::ReplaceMaterializedView;
10835
10836 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10837 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
10838 }
10839
10840 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
10841 where
10842 V: serde::de::MapAccess<'de>,
10843 {
10844 let mut table__ = None;
10845 while let Some(k) = map_.next_key()? {
10846 match k {
10847 GeneratedField::Table => {
10848 if table__.is_some() {
10849 return Err(serde::de::Error::duplicate_field("table"));
10850 }
10851 table__ = map_.next_value()?;
10852 }
10853 }
10854 }
10855 Ok(replace_job_plan::ReplaceMaterializedView {
10856 table: table__,
10857 })
10858 }
10859 }
10860 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
10861 }
10862}
10863impl serde::Serialize for replace_job_plan::ReplaceSource {
10864 #[allow(deprecated)]
10865 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10866 where
10867 S: serde::Serializer,
10868 {
10869 use serde::ser::SerializeStruct;
10870 let mut len = 0;
10871 if self.source.is_some() {
10872 len += 1;
10873 }
10874 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
10875 if let Some(v) = self.source.as_ref() {
10876 struct_ser.serialize_field("source", v)?;
10877 }
10878 struct_ser.end()
10879 }
10880}
10881impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
10882 #[allow(deprecated)]
10883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10884 where
10885 D: serde::Deserializer<'de>,
10886 {
10887 const FIELDS: &[&str] = &[
10888 "source",
10889 ];
10890
10891 #[allow(clippy::enum_variant_names)]
10892 enum GeneratedField {
10893 Source,
10894 }
10895 impl<'de> serde::Deserialize<'de> for GeneratedField {
10896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10897 where
10898 D: serde::Deserializer<'de>,
10899 {
10900 struct GeneratedVisitor;
10901
10902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10903 type Value = GeneratedField;
10904
10905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10906 write!(formatter, "expected one of: {:?}", &FIELDS)
10907 }
10908
10909 #[allow(unused_variables)]
10910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10911 where
10912 E: serde::de::Error,
10913 {
10914 match value {
10915 "source" => Ok(GeneratedField::Source),
10916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10917 }
10918 }
10919 }
10920 deserializer.deserialize_identifier(GeneratedVisitor)
10921 }
10922 }
10923 struct GeneratedVisitor;
10924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10925 type Value = replace_job_plan::ReplaceSource;
10926
10927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10928 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
10929 }
10930
10931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
10932 where
10933 V: serde::de::MapAccess<'de>,
10934 {
10935 let mut source__ = None;
10936 while let Some(k) = map_.next_key()? {
10937 match k {
10938 GeneratedField::Source => {
10939 if source__.is_some() {
10940 return Err(serde::de::Error::duplicate_field("source"));
10941 }
10942 source__ = map_.next_value()?;
10943 }
10944 }
10945 }
10946 Ok(replace_job_plan::ReplaceSource {
10947 source: source__,
10948 })
10949 }
10950 }
10951 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
10952 }
10953}
10954impl serde::Serialize for replace_job_plan::ReplaceTable {
10955 #[allow(deprecated)]
10956 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10957 where
10958 S: serde::Serializer,
10959 {
10960 use serde::ser::SerializeStruct;
10961 let mut len = 0;
10962 if self.table.is_some() {
10963 len += 1;
10964 }
10965 if self.source.is_some() {
10966 len += 1;
10967 }
10968 if self.job_type != 0 {
10969 len += 1;
10970 }
10971 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
10972 if let Some(v) = self.table.as_ref() {
10973 struct_ser.serialize_field("table", v)?;
10974 }
10975 if let Some(v) = self.source.as_ref() {
10976 struct_ser.serialize_field("source", v)?;
10977 }
10978 if self.job_type != 0 {
10979 let v = TableJobType::try_from(self.job_type)
10980 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
10981 struct_ser.serialize_field("jobType", &v)?;
10982 }
10983 struct_ser.end()
10984 }
10985}
10986impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
10987 #[allow(deprecated)]
10988 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10989 where
10990 D: serde::Deserializer<'de>,
10991 {
10992 const FIELDS: &[&str] = &[
10993 "table",
10994 "source",
10995 "job_type",
10996 "jobType",
10997 ];
10998
10999 #[allow(clippy::enum_variant_names)]
11000 enum GeneratedField {
11001 Table,
11002 Source,
11003 JobType,
11004 }
11005 impl<'de> serde::Deserialize<'de> for GeneratedField {
11006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11007 where
11008 D: serde::Deserializer<'de>,
11009 {
11010 struct GeneratedVisitor;
11011
11012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11013 type Value = GeneratedField;
11014
11015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11016 write!(formatter, "expected one of: {:?}", &FIELDS)
11017 }
11018
11019 #[allow(unused_variables)]
11020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11021 where
11022 E: serde::de::Error,
11023 {
11024 match value {
11025 "table" => Ok(GeneratedField::Table),
11026 "source" => Ok(GeneratedField::Source),
11027 "jobType" | "job_type" => Ok(GeneratedField::JobType),
11028 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11029 }
11030 }
11031 }
11032 deserializer.deserialize_identifier(GeneratedVisitor)
11033 }
11034 }
11035 struct GeneratedVisitor;
11036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11037 type Value = replace_job_plan::ReplaceTable;
11038
11039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11040 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
11041 }
11042
11043 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
11044 where
11045 V: serde::de::MapAccess<'de>,
11046 {
11047 let mut table__ = None;
11048 let mut source__ = None;
11049 let mut job_type__ = None;
11050 while let Some(k) = map_.next_key()? {
11051 match k {
11052 GeneratedField::Table => {
11053 if table__.is_some() {
11054 return Err(serde::de::Error::duplicate_field("table"));
11055 }
11056 table__ = map_.next_value()?;
11057 }
11058 GeneratedField::Source => {
11059 if source__.is_some() {
11060 return Err(serde::de::Error::duplicate_field("source"));
11061 }
11062 source__ = map_.next_value()?;
11063 }
11064 GeneratedField::JobType => {
11065 if job_type__.is_some() {
11066 return Err(serde::de::Error::duplicate_field("jobType"));
11067 }
11068 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
11069 }
11070 }
11071 }
11072 Ok(replace_job_plan::ReplaceTable {
11073 table: table__,
11074 source: source__,
11075 job_type: job_type__.unwrap_or_default(),
11076 })
11077 }
11078 }
11079 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
11080 }
11081}
11082impl serde::Serialize for ReplaceJobPlanRequest {
11083 #[allow(deprecated)]
11084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11085 where
11086 S: serde::Serializer,
11087 {
11088 use serde::ser::SerializeStruct;
11089 let mut len = 0;
11090 if self.plan.is_some() {
11091 len += 1;
11092 }
11093 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
11094 if let Some(v) = self.plan.as_ref() {
11095 struct_ser.serialize_field("plan", v)?;
11096 }
11097 struct_ser.end()
11098 }
11099}
11100impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
11101 #[allow(deprecated)]
11102 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11103 where
11104 D: serde::Deserializer<'de>,
11105 {
11106 const FIELDS: &[&str] = &[
11107 "plan",
11108 ];
11109
11110 #[allow(clippy::enum_variant_names)]
11111 enum GeneratedField {
11112 Plan,
11113 }
11114 impl<'de> serde::Deserialize<'de> for GeneratedField {
11115 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11116 where
11117 D: serde::Deserializer<'de>,
11118 {
11119 struct GeneratedVisitor;
11120
11121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11122 type Value = GeneratedField;
11123
11124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11125 write!(formatter, "expected one of: {:?}", &FIELDS)
11126 }
11127
11128 #[allow(unused_variables)]
11129 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11130 where
11131 E: serde::de::Error,
11132 {
11133 match value {
11134 "plan" => Ok(GeneratedField::Plan),
11135 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11136 }
11137 }
11138 }
11139 deserializer.deserialize_identifier(GeneratedVisitor)
11140 }
11141 }
11142 struct GeneratedVisitor;
11143 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11144 type Value = ReplaceJobPlanRequest;
11145
11146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11147 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
11148 }
11149
11150 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
11151 where
11152 V: serde::de::MapAccess<'de>,
11153 {
11154 let mut plan__ = None;
11155 while let Some(k) = map_.next_key()? {
11156 match k {
11157 GeneratedField::Plan => {
11158 if plan__.is_some() {
11159 return Err(serde::de::Error::duplicate_field("plan"));
11160 }
11161 plan__ = map_.next_value()?;
11162 }
11163 }
11164 }
11165 Ok(ReplaceJobPlanRequest {
11166 plan: plan__,
11167 })
11168 }
11169 }
11170 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
11171 }
11172}
11173impl serde::Serialize for ReplaceJobPlanResponse {
11174 #[allow(deprecated)]
11175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11176 where
11177 S: serde::Serializer,
11178 {
11179 use serde::ser::SerializeStruct;
11180 let mut len = 0;
11181 if self.status.is_some() {
11182 len += 1;
11183 }
11184 if self.version.is_some() {
11185 len += 1;
11186 }
11187 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
11188 if let Some(v) = self.status.as_ref() {
11189 struct_ser.serialize_field("status", v)?;
11190 }
11191 if let Some(v) = self.version.as_ref() {
11192 struct_ser.serialize_field("version", v)?;
11193 }
11194 struct_ser.end()
11195 }
11196}
11197impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
11198 #[allow(deprecated)]
11199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11200 where
11201 D: serde::Deserializer<'de>,
11202 {
11203 const FIELDS: &[&str] = &[
11204 "status",
11205 "version",
11206 ];
11207
11208 #[allow(clippy::enum_variant_names)]
11209 enum GeneratedField {
11210 Status,
11211 Version,
11212 }
11213 impl<'de> serde::Deserialize<'de> for GeneratedField {
11214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11215 where
11216 D: serde::Deserializer<'de>,
11217 {
11218 struct GeneratedVisitor;
11219
11220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11221 type Value = GeneratedField;
11222
11223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11224 write!(formatter, "expected one of: {:?}", &FIELDS)
11225 }
11226
11227 #[allow(unused_variables)]
11228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11229 where
11230 E: serde::de::Error,
11231 {
11232 match value {
11233 "status" => Ok(GeneratedField::Status),
11234 "version" => Ok(GeneratedField::Version),
11235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11236 }
11237 }
11238 }
11239 deserializer.deserialize_identifier(GeneratedVisitor)
11240 }
11241 }
11242 struct GeneratedVisitor;
11243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11244 type Value = ReplaceJobPlanResponse;
11245
11246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11247 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
11248 }
11249
11250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
11251 where
11252 V: serde::de::MapAccess<'de>,
11253 {
11254 let mut status__ = None;
11255 let mut version__ = None;
11256 while let Some(k) = map_.next_key()? {
11257 match k {
11258 GeneratedField::Status => {
11259 if status__.is_some() {
11260 return Err(serde::de::Error::duplicate_field("status"));
11261 }
11262 status__ = map_.next_value()?;
11263 }
11264 GeneratedField::Version => {
11265 if version__.is_some() {
11266 return Err(serde::de::Error::duplicate_field("version"));
11267 }
11268 version__ = map_.next_value()?;
11269 }
11270 }
11271 }
11272 Ok(ReplaceJobPlanResponse {
11273 status: status__,
11274 version: version__,
11275 })
11276 }
11277 }
11278 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
11279 }
11280}
11281impl serde::Serialize for RisectlListStateTablesRequest {
11282 #[allow(deprecated)]
11283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11284 where
11285 S: serde::Serializer,
11286 {
11287 use serde::ser::SerializeStruct;
11288 let len = 0;
11289 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
11290 struct_ser.end()
11291 }
11292}
11293impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
11294 #[allow(deprecated)]
11295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11296 where
11297 D: serde::Deserializer<'de>,
11298 {
11299 const FIELDS: &[&str] = &[
11300 ];
11301
11302 #[allow(clippy::enum_variant_names)]
11303 enum GeneratedField {
11304 }
11305 impl<'de> serde::Deserialize<'de> for GeneratedField {
11306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11307 where
11308 D: serde::Deserializer<'de>,
11309 {
11310 struct GeneratedVisitor;
11311
11312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11313 type Value = GeneratedField;
11314
11315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11316 write!(formatter, "expected one of: {:?}", &FIELDS)
11317 }
11318
11319 #[allow(unused_variables)]
11320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11321 where
11322 E: serde::de::Error,
11323 {
11324 Err(serde::de::Error::unknown_field(value, FIELDS))
11325 }
11326 }
11327 deserializer.deserialize_identifier(GeneratedVisitor)
11328 }
11329 }
11330 struct GeneratedVisitor;
11331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11332 type Value = RisectlListStateTablesRequest;
11333
11334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11335 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
11336 }
11337
11338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
11339 where
11340 V: serde::de::MapAccess<'de>,
11341 {
11342 while map_.next_key::<GeneratedField>()?.is_some() {
11343 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11344 }
11345 Ok(RisectlListStateTablesRequest {
11346 })
11347 }
11348 }
11349 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
11350 }
11351}
11352impl serde::Serialize for RisectlListStateTablesResponse {
11353 #[allow(deprecated)]
11354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11355 where
11356 S: serde::Serializer,
11357 {
11358 use serde::ser::SerializeStruct;
11359 let mut len = 0;
11360 if !self.tables.is_empty() {
11361 len += 1;
11362 }
11363 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
11364 if !self.tables.is_empty() {
11365 struct_ser.serialize_field("tables", &self.tables)?;
11366 }
11367 struct_ser.end()
11368 }
11369}
11370impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
11371 #[allow(deprecated)]
11372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11373 where
11374 D: serde::Deserializer<'de>,
11375 {
11376 const FIELDS: &[&str] = &[
11377 "tables",
11378 ];
11379
11380 #[allow(clippy::enum_variant_names)]
11381 enum GeneratedField {
11382 Tables,
11383 }
11384 impl<'de> serde::Deserialize<'de> for GeneratedField {
11385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11386 where
11387 D: serde::Deserializer<'de>,
11388 {
11389 struct GeneratedVisitor;
11390
11391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11392 type Value = GeneratedField;
11393
11394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11395 write!(formatter, "expected one of: {:?}", &FIELDS)
11396 }
11397
11398 #[allow(unused_variables)]
11399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11400 where
11401 E: serde::de::Error,
11402 {
11403 match value {
11404 "tables" => Ok(GeneratedField::Tables),
11405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11406 }
11407 }
11408 }
11409 deserializer.deserialize_identifier(GeneratedVisitor)
11410 }
11411 }
11412 struct GeneratedVisitor;
11413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11414 type Value = RisectlListStateTablesResponse;
11415
11416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11417 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
11418 }
11419
11420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
11421 where
11422 V: serde::de::MapAccess<'de>,
11423 {
11424 let mut tables__ = None;
11425 while let Some(k) = map_.next_key()? {
11426 match k {
11427 GeneratedField::Tables => {
11428 if tables__.is_some() {
11429 return Err(serde::de::Error::duplicate_field("tables"));
11430 }
11431 tables__ = Some(map_.next_value()?);
11432 }
11433 }
11434 }
11435 Ok(RisectlListStateTablesResponse {
11436 tables: tables__.unwrap_or_default(),
11437 })
11438 }
11439 }
11440 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
11441 }
11442}
11443impl serde::Serialize for SchemaChangeEnvelope {
11444 #[allow(deprecated)]
11445 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11446 where
11447 S: serde::Serializer,
11448 {
11449 use serde::ser::SerializeStruct;
11450 let mut len = 0;
11451 if !self.table_changes.is_empty() {
11452 len += 1;
11453 }
11454 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
11455 if !self.table_changes.is_empty() {
11456 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
11457 }
11458 struct_ser.end()
11459 }
11460}
11461impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
11462 #[allow(deprecated)]
11463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11464 where
11465 D: serde::Deserializer<'de>,
11466 {
11467 const FIELDS: &[&str] = &[
11468 "table_changes",
11469 "tableChanges",
11470 ];
11471
11472 #[allow(clippy::enum_variant_names)]
11473 enum GeneratedField {
11474 TableChanges,
11475 }
11476 impl<'de> serde::Deserialize<'de> for GeneratedField {
11477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11478 where
11479 D: serde::Deserializer<'de>,
11480 {
11481 struct GeneratedVisitor;
11482
11483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11484 type Value = GeneratedField;
11485
11486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11487 write!(formatter, "expected one of: {:?}", &FIELDS)
11488 }
11489
11490 #[allow(unused_variables)]
11491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11492 where
11493 E: serde::de::Error,
11494 {
11495 match value {
11496 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
11497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11498 }
11499 }
11500 }
11501 deserializer.deserialize_identifier(GeneratedVisitor)
11502 }
11503 }
11504 struct GeneratedVisitor;
11505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11506 type Value = SchemaChangeEnvelope;
11507
11508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11509 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
11510 }
11511
11512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
11513 where
11514 V: serde::de::MapAccess<'de>,
11515 {
11516 let mut table_changes__ = None;
11517 while let Some(k) = map_.next_key()? {
11518 match k {
11519 GeneratedField::TableChanges => {
11520 if table_changes__.is_some() {
11521 return Err(serde::de::Error::duplicate_field("tableChanges"));
11522 }
11523 table_changes__ = Some(map_.next_value()?);
11524 }
11525 }
11526 }
11527 Ok(SchemaChangeEnvelope {
11528 table_changes: table_changes__.unwrap_or_default(),
11529 })
11530 }
11531 }
11532 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
11533 }
11534}
11535impl serde::Serialize for TableJobType {
11536 #[allow(deprecated)]
11537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11538 where
11539 S: serde::Serializer,
11540 {
11541 let variant = match self {
11542 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
11543 Self::General => "TABLE_JOB_TYPE_GENERAL",
11544 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
11545 };
11546 serializer.serialize_str(variant)
11547 }
11548}
11549impl<'de> serde::Deserialize<'de> for TableJobType {
11550 #[allow(deprecated)]
11551 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11552 where
11553 D: serde::Deserializer<'de>,
11554 {
11555 const FIELDS: &[&str] = &[
11556 "TABLE_JOB_TYPE_UNSPECIFIED",
11557 "TABLE_JOB_TYPE_GENERAL",
11558 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
11559 ];
11560
11561 struct GeneratedVisitor;
11562
11563 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11564 type Value = TableJobType;
11565
11566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11567 write!(formatter, "expected one of: {:?}", &FIELDS)
11568 }
11569
11570 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11571 where
11572 E: serde::de::Error,
11573 {
11574 i32::try_from(v)
11575 .ok()
11576 .and_then(|x| x.try_into().ok())
11577 .ok_or_else(|| {
11578 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11579 })
11580 }
11581
11582 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11583 where
11584 E: serde::de::Error,
11585 {
11586 i32::try_from(v)
11587 .ok()
11588 .and_then(|x| x.try_into().ok())
11589 .ok_or_else(|| {
11590 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11591 })
11592 }
11593
11594 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11595 where
11596 E: serde::de::Error,
11597 {
11598 match value {
11599 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
11600 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
11601 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
11602 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11603 }
11604 }
11605 }
11606 deserializer.deserialize_any(GeneratedVisitor)
11607 }
11608}
11609impl serde::Serialize for TableSchemaChange {
11610 #[allow(deprecated)]
11611 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11612 where
11613 S: serde::Serializer,
11614 {
11615 use serde::ser::SerializeStruct;
11616 let mut len = 0;
11617 if self.change_type != 0 {
11618 len += 1;
11619 }
11620 if !self.cdc_table_id.is_empty() {
11621 len += 1;
11622 }
11623 if !self.columns.is_empty() {
11624 len += 1;
11625 }
11626 if !self.upstream_ddl.is_empty() {
11627 len += 1;
11628 }
11629 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
11630 if self.change_type != 0 {
11631 let v = table_schema_change::TableChangeType::try_from(self.change_type)
11632 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
11633 struct_ser.serialize_field("changeType", &v)?;
11634 }
11635 if !self.cdc_table_id.is_empty() {
11636 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
11637 }
11638 if !self.columns.is_empty() {
11639 struct_ser.serialize_field("columns", &self.columns)?;
11640 }
11641 if !self.upstream_ddl.is_empty() {
11642 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
11643 }
11644 struct_ser.end()
11645 }
11646}
11647impl<'de> serde::Deserialize<'de> for TableSchemaChange {
11648 #[allow(deprecated)]
11649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11650 where
11651 D: serde::Deserializer<'de>,
11652 {
11653 const FIELDS: &[&str] = &[
11654 "change_type",
11655 "changeType",
11656 "cdc_table_id",
11657 "cdcTableId",
11658 "columns",
11659 "upstream_ddl",
11660 "upstreamDdl",
11661 ];
11662
11663 #[allow(clippy::enum_variant_names)]
11664 enum GeneratedField {
11665 ChangeType,
11666 CdcTableId,
11667 Columns,
11668 UpstreamDdl,
11669 }
11670 impl<'de> serde::Deserialize<'de> for GeneratedField {
11671 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11672 where
11673 D: serde::Deserializer<'de>,
11674 {
11675 struct GeneratedVisitor;
11676
11677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11678 type Value = GeneratedField;
11679
11680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11681 write!(formatter, "expected one of: {:?}", &FIELDS)
11682 }
11683
11684 #[allow(unused_variables)]
11685 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11686 where
11687 E: serde::de::Error,
11688 {
11689 match value {
11690 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
11691 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
11692 "columns" => Ok(GeneratedField::Columns),
11693 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
11694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11695 }
11696 }
11697 }
11698 deserializer.deserialize_identifier(GeneratedVisitor)
11699 }
11700 }
11701 struct GeneratedVisitor;
11702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11703 type Value = TableSchemaChange;
11704
11705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11706 formatter.write_str("struct ddl_service.TableSchemaChange")
11707 }
11708
11709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
11710 where
11711 V: serde::de::MapAccess<'de>,
11712 {
11713 let mut change_type__ = None;
11714 let mut cdc_table_id__ = None;
11715 let mut columns__ = None;
11716 let mut upstream_ddl__ = None;
11717 while let Some(k) = map_.next_key()? {
11718 match k {
11719 GeneratedField::ChangeType => {
11720 if change_type__.is_some() {
11721 return Err(serde::de::Error::duplicate_field("changeType"));
11722 }
11723 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
11724 }
11725 GeneratedField::CdcTableId => {
11726 if cdc_table_id__.is_some() {
11727 return Err(serde::de::Error::duplicate_field("cdcTableId"));
11728 }
11729 cdc_table_id__ = Some(map_.next_value()?);
11730 }
11731 GeneratedField::Columns => {
11732 if columns__.is_some() {
11733 return Err(serde::de::Error::duplicate_field("columns"));
11734 }
11735 columns__ = Some(map_.next_value()?);
11736 }
11737 GeneratedField::UpstreamDdl => {
11738 if upstream_ddl__.is_some() {
11739 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
11740 }
11741 upstream_ddl__ = Some(map_.next_value()?);
11742 }
11743 }
11744 }
11745 Ok(TableSchemaChange {
11746 change_type: change_type__.unwrap_or_default(),
11747 cdc_table_id: cdc_table_id__.unwrap_or_default(),
11748 columns: columns__.unwrap_or_default(),
11749 upstream_ddl: upstream_ddl__.unwrap_or_default(),
11750 })
11751 }
11752 }
11753 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
11754 }
11755}
11756impl serde::Serialize for table_schema_change::TableChangeType {
11757 #[allow(deprecated)]
11758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11759 where
11760 S: serde::Serializer,
11761 {
11762 let variant = match self {
11763 Self::Unspecified => "UNSPECIFIED",
11764 Self::Alter => "ALTER",
11765 Self::Create => "CREATE",
11766 Self::Drop => "DROP",
11767 };
11768 serializer.serialize_str(variant)
11769 }
11770}
11771impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
11772 #[allow(deprecated)]
11773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11774 where
11775 D: serde::Deserializer<'de>,
11776 {
11777 const FIELDS: &[&str] = &[
11778 "UNSPECIFIED",
11779 "ALTER",
11780 "CREATE",
11781 "DROP",
11782 ];
11783
11784 struct GeneratedVisitor;
11785
11786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11787 type Value = table_schema_change::TableChangeType;
11788
11789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11790 write!(formatter, "expected one of: {:?}", &FIELDS)
11791 }
11792
11793 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11794 where
11795 E: serde::de::Error,
11796 {
11797 i32::try_from(v)
11798 .ok()
11799 .and_then(|x| x.try_into().ok())
11800 .ok_or_else(|| {
11801 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11802 })
11803 }
11804
11805 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11806 where
11807 E: serde::de::Error,
11808 {
11809 i32::try_from(v)
11810 .ok()
11811 .and_then(|x| x.try_into().ok())
11812 .ok_or_else(|| {
11813 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11814 })
11815 }
11816
11817 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11818 where
11819 E: serde::de::Error,
11820 {
11821 match value {
11822 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
11823 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
11824 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
11825 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
11826 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11827 }
11828 }
11829 }
11830 deserializer.deserialize_any(GeneratedVisitor)
11831 }
11832}
11833impl serde::Serialize for WaitRequest {
11834 #[allow(deprecated)]
11835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11836 where
11837 S: serde::Serializer,
11838 {
11839 use serde::ser::SerializeStruct;
11840 let len = 0;
11841 let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
11842 struct_ser.end()
11843 }
11844}
11845impl<'de> serde::Deserialize<'de> for WaitRequest {
11846 #[allow(deprecated)]
11847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11848 where
11849 D: serde::Deserializer<'de>,
11850 {
11851 const FIELDS: &[&str] = &[
11852 ];
11853
11854 #[allow(clippy::enum_variant_names)]
11855 enum GeneratedField {
11856 }
11857 impl<'de> serde::Deserialize<'de> for GeneratedField {
11858 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11859 where
11860 D: serde::Deserializer<'de>,
11861 {
11862 struct GeneratedVisitor;
11863
11864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11865 type Value = GeneratedField;
11866
11867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11868 write!(formatter, "expected one of: {:?}", &FIELDS)
11869 }
11870
11871 #[allow(unused_variables)]
11872 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11873 where
11874 E: serde::de::Error,
11875 {
11876 Err(serde::de::Error::unknown_field(value, FIELDS))
11877 }
11878 }
11879 deserializer.deserialize_identifier(GeneratedVisitor)
11880 }
11881 }
11882 struct GeneratedVisitor;
11883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11884 type Value = WaitRequest;
11885
11886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11887 formatter.write_str("struct ddl_service.WaitRequest")
11888 }
11889
11890 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
11891 where
11892 V: serde::de::MapAccess<'de>,
11893 {
11894 while map_.next_key::<GeneratedField>()?.is_some() {
11895 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11896 }
11897 Ok(WaitRequest {
11898 })
11899 }
11900 }
11901 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
11902 }
11903}
11904impl serde::Serialize for WaitResponse {
11905 #[allow(deprecated)]
11906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11907 where
11908 S: serde::Serializer,
11909 {
11910 use serde::ser::SerializeStruct;
11911 let len = 0;
11912 let struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
11913 struct_ser.end()
11914 }
11915}
11916impl<'de> serde::Deserialize<'de> for WaitResponse {
11917 #[allow(deprecated)]
11918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11919 where
11920 D: serde::Deserializer<'de>,
11921 {
11922 const FIELDS: &[&str] = &[
11923 ];
11924
11925 #[allow(clippy::enum_variant_names)]
11926 enum GeneratedField {
11927 }
11928 impl<'de> serde::Deserialize<'de> for GeneratedField {
11929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11930 where
11931 D: serde::Deserializer<'de>,
11932 {
11933 struct GeneratedVisitor;
11934
11935 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11936 type Value = GeneratedField;
11937
11938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11939 write!(formatter, "expected one of: {:?}", &FIELDS)
11940 }
11941
11942 #[allow(unused_variables)]
11943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11944 where
11945 E: serde::de::Error,
11946 {
11947 Err(serde::de::Error::unknown_field(value, FIELDS))
11948 }
11949 }
11950 deserializer.deserialize_identifier(GeneratedVisitor)
11951 }
11952 }
11953 struct GeneratedVisitor;
11954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11955 type Value = WaitResponse;
11956
11957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11958 formatter.write_str("struct ddl_service.WaitResponse")
11959 }
11960
11961 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
11962 where
11963 V: serde::de::MapAccess<'de>,
11964 {
11965 while map_.next_key::<GeneratedField>()?.is_some() {
11966 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11967 }
11968 Ok(WaitResponse {
11969 })
11970 }
11971 }
11972 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
11973 }
11974}
11975impl serde::Serialize for WaitVersion {
11976 #[allow(deprecated)]
11977 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11978 where
11979 S: serde::Serializer,
11980 {
11981 use serde::ser::SerializeStruct;
11982 let mut len = 0;
11983 if self.catalog_version != 0 {
11984 len += 1;
11985 }
11986 if self.hummock_version_id != 0 {
11987 len += 1;
11988 }
11989 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
11990 if self.catalog_version != 0 {
11991 #[allow(clippy::needless_borrow)]
11992 #[allow(clippy::needless_borrows_for_generic_args)]
11993 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11994 }
11995 if self.hummock_version_id != 0 {
11996 #[allow(clippy::needless_borrow)]
11997 #[allow(clippy::needless_borrows_for_generic_args)]
11998 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
11999 }
12000 struct_ser.end()
12001 }
12002}
12003impl<'de> serde::Deserialize<'de> for WaitVersion {
12004 #[allow(deprecated)]
12005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12006 where
12007 D: serde::Deserializer<'de>,
12008 {
12009 const FIELDS: &[&str] = &[
12010 "catalog_version",
12011 "catalogVersion",
12012 "hummock_version_id",
12013 "hummockVersionId",
12014 ];
12015
12016 #[allow(clippy::enum_variant_names)]
12017 enum GeneratedField {
12018 CatalogVersion,
12019 HummockVersionId,
12020 }
12021 impl<'de> serde::Deserialize<'de> for GeneratedField {
12022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12023 where
12024 D: serde::Deserializer<'de>,
12025 {
12026 struct GeneratedVisitor;
12027
12028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12029 type Value = GeneratedField;
12030
12031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12032 write!(formatter, "expected one of: {:?}", &FIELDS)
12033 }
12034
12035 #[allow(unused_variables)]
12036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12037 where
12038 E: serde::de::Error,
12039 {
12040 match value {
12041 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12042 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
12043 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12044 }
12045 }
12046 }
12047 deserializer.deserialize_identifier(GeneratedVisitor)
12048 }
12049 }
12050 struct GeneratedVisitor;
12051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12052 type Value = WaitVersion;
12053
12054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12055 formatter.write_str("struct ddl_service.WaitVersion")
12056 }
12057
12058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
12059 where
12060 V: serde::de::MapAccess<'de>,
12061 {
12062 let mut catalog_version__ = None;
12063 let mut hummock_version_id__ = None;
12064 while let Some(k) = map_.next_key()? {
12065 match k {
12066 GeneratedField::CatalogVersion => {
12067 if catalog_version__.is_some() {
12068 return Err(serde::de::Error::duplicate_field("catalogVersion"));
12069 }
12070 catalog_version__ =
12071 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12072 ;
12073 }
12074 GeneratedField::HummockVersionId => {
12075 if hummock_version_id__.is_some() {
12076 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
12077 }
12078 hummock_version_id__ =
12079 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12080 ;
12081 }
12082 }
12083 }
12084 Ok(WaitVersion {
12085 catalog_version: catalog_version__.unwrap_or_default(),
12086 hummock_version_id: hummock_version_id__.unwrap_or_default(),
12087 })
12088 }
12089 }
12090 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
12091 }
12092}