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