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.dependencies.is_empty() {
5088 len += 1;
5089 }
5090 if self.if_not_exists {
5091 len += 1;
5092 }
5093 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkRequest", len)?;
5094 if let Some(v) = self.sink.as_ref() {
5095 struct_ser.serialize_field("sink", v)?;
5096 }
5097 if let Some(v) = self.fragment_graph.as_ref() {
5098 struct_ser.serialize_field("fragmentGraph", v)?;
5099 }
5100 if !self.dependencies.is_empty() {
5101 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5102 }
5103 if self.if_not_exists {
5104 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5105 }
5106 struct_ser.end()
5107 }
5108}
5109impl<'de> serde::Deserialize<'de> for CreateSinkRequest {
5110 #[allow(deprecated)]
5111 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5112 where
5113 D: serde::Deserializer<'de>,
5114 {
5115 const FIELDS: &[&str] = &[
5116 "sink",
5117 "fragment_graph",
5118 "fragmentGraph",
5119 "dependencies",
5120 "if_not_exists",
5121 "ifNotExists",
5122 ];
5123
5124 #[allow(clippy::enum_variant_names)]
5125 enum GeneratedField {
5126 Sink,
5127 FragmentGraph,
5128 Dependencies,
5129 IfNotExists,
5130 }
5131 impl<'de> serde::Deserialize<'de> for GeneratedField {
5132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5133 where
5134 D: serde::Deserializer<'de>,
5135 {
5136 struct GeneratedVisitor;
5137
5138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5139 type Value = GeneratedField;
5140
5141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142 write!(formatter, "expected one of: {:?}", &FIELDS)
5143 }
5144
5145 #[allow(unused_variables)]
5146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5147 where
5148 E: serde::de::Error,
5149 {
5150 match value {
5151 "sink" => Ok(GeneratedField::Sink),
5152 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5153 "dependencies" => Ok(GeneratedField::Dependencies),
5154 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5156 }
5157 }
5158 }
5159 deserializer.deserialize_identifier(GeneratedVisitor)
5160 }
5161 }
5162 struct GeneratedVisitor;
5163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5164 type Value = CreateSinkRequest;
5165
5166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5167 formatter.write_str("struct ddl_service.CreateSinkRequest")
5168 }
5169
5170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkRequest, V::Error>
5171 where
5172 V: serde::de::MapAccess<'de>,
5173 {
5174 let mut sink__ = None;
5175 let mut fragment_graph__ = None;
5176 let mut dependencies__ = None;
5177 let mut if_not_exists__ = None;
5178 while let Some(k) = map_.next_key()? {
5179 match k {
5180 GeneratedField::Sink => {
5181 if sink__.is_some() {
5182 return Err(serde::de::Error::duplicate_field("sink"));
5183 }
5184 sink__ = map_.next_value()?;
5185 }
5186 GeneratedField::FragmentGraph => {
5187 if fragment_graph__.is_some() {
5188 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5189 }
5190 fragment_graph__ = map_.next_value()?;
5191 }
5192 GeneratedField::Dependencies => {
5193 if dependencies__.is_some() {
5194 return Err(serde::de::Error::duplicate_field("dependencies"));
5195 }
5196 dependencies__ =
5197 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5198 .into_iter().map(|x| x.0).collect())
5199 ;
5200 }
5201 GeneratedField::IfNotExists => {
5202 if if_not_exists__.is_some() {
5203 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5204 }
5205 if_not_exists__ = Some(map_.next_value()?);
5206 }
5207 }
5208 }
5209 Ok(CreateSinkRequest {
5210 sink: sink__,
5211 fragment_graph: fragment_graph__,
5212 dependencies: dependencies__.unwrap_or_default(),
5213 if_not_exists: if_not_exists__.unwrap_or_default(),
5214 })
5215 }
5216 }
5217 deserializer.deserialize_struct("ddl_service.CreateSinkRequest", FIELDS, GeneratedVisitor)
5218 }
5219}
5220impl serde::Serialize for CreateSinkResponse {
5221 #[allow(deprecated)]
5222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5223 where
5224 S: serde::Serializer,
5225 {
5226 use serde::ser::SerializeStruct;
5227 let mut len = 0;
5228 if self.status.is_some() {
5229 len += 1;
5230 }
5231 if self.version.is_some() {
5232 len += 1;
5233 }
5234 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSinkResponse", len)?;
5235 if let Some(v) = self.status.as_ref() {
5236 struct_ser.serialize_field("status", v)?;
5237 }
5238 if let Some(v) = self.version.as_ref() {
5239 struct_ser.serialize_field("version", v)?;
5240 }
5241 struct_ser.end()
5242 }
5243}
5244impl<'de> serde::Deserialize<'de> for CreateSinkResponse {
5245 #[allow(deprecated)]
5246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5247 where
5248 D: serde::Deserializer<'de>,
5249 {
5250 const FIELDS: &[&str] = &[
5251 "status",
5252 "version",
5253 ];
5254
5255 #[allow(clippy::enum_variant_names)]
5256 enum GeneratedField {
5257 Status,
5258 Version,
5259 }
5260 impl<'de> serde::Deserialize<'de> for GeneratedField {
5261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5262 where
5263 D: serde::Deserializer<'de>,
5264 {
5265 struct GeneratedVisitor;
5266
5267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5268 type Value = GeneratedField;
5269
5270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5271 write!(formatter, "expected one of: {:?}", &FIELDS)
5272 }
5273
5274 #[allow(unused_variables)]
5275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5276 where
5277 E: serde::de::Error,
5278 {
5279 match value {
5280 "status" => Ok(GeneratedField::Status),
5281 "version" => Ok(GeneratedField::Version),
5282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5283 }
5284 }
5285 }
5286 deserializer.deserialize_identifier(GeneratedVisitor)
5287 }
5288 }
5289 struct GeneratedVisitor;
5290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5291 type Value = CreateSinkResponse;
5292
5293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5294 formatter.write_str("struct ddl_service.CreateSinkResponse")
5295 }
5296
5297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSinkResponse, V::Error>
5298 where
5299 V: serde::de::MapAccess<'de>,
5300 {
5301 let mut status__ = None;
5302 let mut version__ = None;
5303 while let Some(k) = map_.next_key()? {
5304 match k {
5305 GeneratedField::Status => {
5306 if status__.is_some() {
5307 return Err(serde::de::Error::duplicate_field("status"));
5308 }
5309 status__ = map_.next_value()?;
5310 }
5311 GeneratedField::Version => {
5312 if version__.is_some() {
5313 return Err(serde::de::Error::duplicate_field("version"));
5314 }
5315 version__ = map_.next_value()?;
5316 }
5317 }
5318 }
5319 Ok(CreateSinkResponse {
5320 status: status__,
5321 version: version__,
5322 })
5323 }
5324 }
5325 deserializer.deserialize_struct("ddl_service.CreateSinkResponse", FIELDS, GeneratedVisitor)
5326 }
5327}
5328impl serde::Serialize for CreateSourceRequest {
5329 #[allow(deprecated)]
5330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5331 where
5332 S: serde::Serializer,
5333 {
5334 use serde::ser::SerializeStruct;
5335 let mut len = 0;
5336 if self.source.is_some() {
5337 len += 1;
5338 }
5339 if self.fragment_graph.is_some() {
5340 len += 1;
5341 }
5342 if self.if_not_exists {
5343 len += 1;
5344 }
5345 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceRequest", len)?;
5346 if let Some(v) = self.source.as_ref() {
5347 struct_ser.serialize_field("source", v)?;
5348 }
5349 if let Some(v) = self.fragment_graph.as_ref() {
5350 struct_ser.serialize_field("fragmentGraph", v)?;
5351 }
5352 if self.if_not_exists {
5353 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5354 }
5355 struct_ser.end()
5356 }
5357}
5358impl<'de> serde::Deserialize<'de> for CreateSourceRequest {
5359 #[allow(deprecated)]
5360 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5361 where
5362 D: serde::Deserializer<'de>,
5363 {
5364 const FIELDS: &[&str] = &[
5365 "source",
5366 "fragment_graph",
5367 "fragmentGraph",
5368 "if_not_exists",
5369 "ifNotExists",
5370 ];
5371
5372 #[allow(clippy::enum_variant_names)]
5373 enum GeneratedField {
5374 Source,
5375 FragmentGraph,
5376 IfNotExists,
5377 }
5378 impl<'de> serde::Deserialize<'de> for GeneratedField {
5379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5380 where
5381 D: serde::Deserializer<'de>,
5382 {
5383 struct GeneratedVisitor;
5384
5385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5386 type Value = GeneratedField;
5387
5388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5389 write!(formatter, "expected one of: {:?}", &FIELDS)
5390 }
5391
5392 #[allow(unused_variables)]
5393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5394 where
5395 E: serde::de::Error,
5396 {
5397 match value {
5398 "source" => Ok(GeneratedField::Source),
5399 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5400 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5402 }
5403 }
5404 }
5405 deserializer.deserialize_identifier(GeneratedVisitor)
5406 }
5407 }
5408 struct GeneratedVisitor;
5409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5410 type Value = CreateSourceRequest;
5411
5412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5413 formatter.write_str("struct ddl_service.CreateSourceRequest")
5414 }
5415
5416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceRequest, V::Error>
5417 where
5418 V: serde::de::MapAccess<'de>,
5419 {
5420 let mut source__ = None;
5421 let mut fragment_graph__ = None;
5422 let mut if_not_exists__ = None;
5423 while let Some(k) = map_.next_key()? {
5424 match k {
5425 GeneratedField::Source => {
5426 if source__.is_some() {
5427 return Err(serde::de::Error::duplicate_field("source"));
5428 }
5429 source__ = map_.next_value()?;
5430 }
5431 GeneratedField::FragmentGraph => {
5432 if fragment_graph__.is_some() {
5433 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5434 }
5435 fragment_graph__ = map_.next_value()?;
5436 }
5437 GeneratedField::IfNotExists => {
5438 if if_not_exists__.is_some() {
5439 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5440 }
5441 if_not_exists__ = Some(map_.next_value()?);
5442 }
5443 }
5444 }
5445 Ok(CreateSourceRequest {
5446 source: source__,
5447 fragment_graph: fragment_graph__,
5448 if_not_exists: if_not_exists__.unwrap_or_default(),
5449 })
5450 }
5451 }
5452 deserializer.deserialize_struct("ddl_service.CreateSourceRequest", FIELDS, GeneratedVisitor)
5453 }
5454}
5455impl serde::Serialize for CreateSourceResponse {
5456 #[allow(deprecated)]
5457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5458 where
5459 S: serde::Serializer,
5460 {
5461 use serde::ser::SerializeStruct;
5462 let mut len = 0;
5463 if self.status.is_some() {
5464 len += 1;
5465 }
5466 if self.version.is_some() {
5467 len += 1;
5468 }
5469 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSourceResponse", len)?;
5470 if let Some(v) = self.status.as_ref() {
5471 struct_ser.serialize_field("status", v)?;
5472 }
5473 if let Some(v) = self.version.as_ref() {
5474 struct_ser.serialize_field("version", v)?;
5475 }
5476 struct_ser.end()
5477 }
5478}
5479impl<'de> serde::Deserialize<'de> for CreateSourceResponse {
5480 #[allow(deprecated)]
5481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5482 where
5483 D: serde::Deserializer<'de>,
5484 {
5485 const FIELDS: &[&str] = &[
5486 "status",
5487 "version",
5488 ];
5489
5490 #[allow(clippy::enum_variant_names)]
5491 enum GeneratedField {
5492 Status,
5493 Version,
5494 }
5495 impl<'de> serde::Deserialize<'de> for GeneratedField {
5496 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5497 where
5498 D: serde::Deserializer<'de>,
5499 {
5500 struct GeneratedVisitor;
5501
5502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5503 type Value = GeneratedField;
5504
5505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5506 write!(formatter, "expected one of: {:?}", &FIELDS)
5507 }
5508
5509 #[allow(unused_variables)]
5510 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5511 where
5512 E: serde::de::Error,
5513 {
5514 match value {
5515 "status" => Ok(GeneratedField::Status),
5516 "version" => Ok(GeneratedField::Version),
5517 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5518 }
5519 }
5520 }
5521 deserializer.deserialize_identifier(GeneratedVisitor)
5522 }
5523 }
5524 struct GeneratedVisitor;
5525 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5526 type Value = CreateSourceResponse;
5527
5528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5529 formatter.write_str("struct ddl_service.CreateSourceResponse")
5530 }
5531
5532 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSourceResponse, V::Error>
5533 where
5534 V: serde::de::MapAccess<'de>,
5535 {
5536 let mut status__ = None;
5537 let mut version__ = None;
5538 while let Some(k) = map_.next_key()? {
5539 match k {
5540 GeneratedField::Status => {
5541 if status__.is_some() {
5542 return Err(serde::de::Error::duplicate_field("status"));
5543 }
5544 status__ = map_.next_value()?;
5545 }
5546 GeneratedField::Version => {
5547 if version__.is_some() {
5548 return Err(serde::de::Error::duplicate_field("version"));
5549 }
5550 version__ = map_.next_value()?;
5551 }
5552 }
5553 }
5554 Ok(CreateSourceResponse {
5555 status: status__,
5556 version: version__,
5557 })
5558 }
5559 }
5560 deserializer.deserialize_struct("ddl_service.CreateSourceResponse", FIELDS, GeneratedVisitor)
5561 }
5562}
5563impl serde::Serialize for CreateSubscriptionRequest {
5564 #[allow(deprecated)]
5565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5566 where
5567 S: serde::Serializer,
5568 {
5569 use serde::ser::SerializeStruct;
5570 let mut len = 0;
5571 if self.subscription.is_some() {
5572 len += 1;
5573 }
5574 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionRequest", len)?;
5575 if let Some(v) = self.subscription.as_ref() {
5576 struct_ser.serialize_field("subscription", v)?;
5577 }
5578 struct_ser.end()
5579 }
5580}
5581impl<'de> serde::Deserialize<'de> for CreateSubscriptionRequest {
5582 #[allow(deprecated)]
5583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5584 where
5585 D: serde::Deserializer<'de>,
5586 {
5587 const FIELDS: &[&str] = &[
5588 "subscription",
5589 ];
5590
5591 #[allow(clippy::enum_variant_names)]
5592 enum GeneratedField {
5593 Subscription,
5594 }
5595 impl<'de> serde::Deserialize<'de> for GeneratedField {
5596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5597 where
5598 D: serde::Deserializer<'de>,
5599 {
5600 struct GeneratedVisitor;
5601
5602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5603 type Value = GeneratedField;
5604
5605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5606 write!(formatter, "expected one of: {:?}", &FIELDS)
5607 }
5608
5609 #[allow(unused_variables)]
5610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5611 where
5612 E: serde::de::Error,
5613 {
5614 match value {
5615 "subscription" => Ok(GeneratedField::Subscription),
5616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5617 }
5618 }
5619 }
5620 deserializer.deserialize_identifier(GeneratedVisitor)
5621 }
5622 }
5623 struct GeneratedVisitor;
5624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5625 type Value = CreateSubscriptionRequest;
5626
5627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5628 formatter.write_str("struct ddl_service.CreateSubscriptionRequest")
5629 }
5630
5631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionRequest, V::Error>
5632 where
5633 V: serde::de::MapAccess<'de>,
5634 {
5635 let mut subscription__ = None;
5636 while let Some(k) = map_.next_key()? {
5637 match k {
5638 GeneratedField::Subscription => {
5639 if subscription__.is_some() {
5640 return Err(serde::de::Error::duplicate_field("subscription"));
5641 }
5642 subscription__ = map_.next_value()?;
5643 }
5644 }
5645 }
5646 Ok(CreateSubscriptionRequest {
5647 subscription: subscription__,
5648 })
5649 }
5650 }
5651 deserializer.deserialize_struct("ddl_service.CreateSubscriptionRequest", FIELDS, GeneratedVisitor)
5652 }
5653}
5654impl serde::Serialize for CreateSubscriptionResponse {
5655 #[allow(deprecated)]
5656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5657 where
5658 S: serde::Serializer,
5659 {
5660 use serde::ser::SerializeStruct;
5661 let mut len = 0;
5662 if self.status.is_some() {
5663 len += 1;
5664 }
5665 if self.version.is_some() {
5666 len += 1;
5667 }
5668 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateSubscriptionResponse", len)?;
5669 if let Some(v) = self.status.as_ref() {
5670 struct_ser.serialize_field("status", v)?;
5671 }
5672 if let Some(v) = self.version.as_ref() {
5673 struct_ser.serialize_field("version", v)?;
5674 }
5675 struct_ser.end()
5676 }
5677}
5678impl<'de> serde::Deserialize<'de> for CreateSubscriptionResponse {
5679 #[allow(deprecated)]
5680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5681 where
5682 D: serde::Deserializer<'de>,
5683 {
5684 const FIELDS: &[&str] = &[
5685 "status",
5686 "version",
5687 ];
5688
5689 #[allow(clippy::enum_variant_names)]
5690 enum GeneratedField {
5691 Status,
5692 Version,
5693 }
5694 impl<'de> serde::Deserialize<'de> for GeneratedField {
5695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5696 where
5697 D: serde::Deserializer<'de>,
5698 {
5699 struct GeneratedVisitor;
5700
5701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5702 type Value = GeneratedField;
5703
5704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5705 write!(formatter, "expected one of: {:?}", &FIELDS)
5706 }
5707
5708 #[allow(unused_variables)]
5709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5710 where
5711 E: serde::de::Error,
5712 {
5713 match value {
5714 "status" => Ok(GeneratedField::Status),
5715 "version" => Ok(GeneratedField::Version),
5716 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5717 }
5718 }
5719 }
5720 deserializer.deserialize_identifier(GeneratedVisitor)
5721 }
5722 }
5723 struct GeneratedVisitor;
5724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5725 type Value = CreateSubscriptionResponse;
5726
5727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5728 formatter.write_str("struct ddl_service.CreateSubscriptionResponse")
5729 }
5730
5731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateSubscriptionResponse, V::Error>
5732 where
5733 V: serde::de::MapAccess<'de>,
5734 {
5735 let mut status__ = None;
5736 let mut version__ = None;
5737 while let Some(k) = map_.next_key()? {
5738 match k {
5739 GeneratedField::Status => {
5740 if status__.is_some() {
5741 return Err(serde::de::Error::duplicate_field("status"));
5742 }
5743 status__ = map_.next_value()?;
5744 }
5745 GeneratedField::Version => {
5746 if version__.is_some() {
5747 return Err(serde::de::Error::duplicate_field("version"));
5748 }
5749 version__ = map_.next_value()?;
5750 }
5751 }
5752 }
5753 Ok(CreateSubscriptionResponse {
5754 status: status__,
5755 version: version__,
5756 })
5757 }
5758 }
5759 deserializer.deserialize_struct("ddl_service.CreateSubscriptionResponse", FIELDS, GeneratedVisitor)
5760 }
5761}
5762impl serde::Serialize for CreateTableRequest {
5763 #[allow(deprecated)]
5764 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5765 where
5766 S: serde::Serializer,
5767 {
5768 use serde::ser::SerializeStruct;
5769 let mut len = 0;
5770 if self.source.is_some() {
5771 len += 1;
5772 }
5773 if self.materialized_view.is_some() {
5774 len += 1;
5775 }
5776 if self.fragment_graph.is_some() {
5777 len += 1;
5778 }
5779 if self.job_type != 0 {
5780 len += 1;
5781 }
5782 if self.if_not_exists {
5783 len += 1;
5784 }
5785 if !self.dependencies.is_empty() {
5786 len += 1;
5787 }
5788 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableRequest", len)?;
5789 if let Some(v) = self.source.as_ref() {
5790 struct_ser.serialize_field("source", v)?;
5791 }
5792 if let Some(v) = self.materialized_view.as_ref() {
5793 struct_ser.serialize_field("materializedView", v)?;
5794 }
5795 if let Some(v) = self.fragment_graph.as_ref() {
5796 struct_ser.serialize_field("fragmentGraph", v)?;
5797 }
5798 if self.job_type != 0 {
5799 let v = TableJobType::try_from(self.job_type)
5800 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
5801 struct_ser.serialize_field("jobType", &v)?;
5802 }
5803 if self.if_not_exists {
5804 struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
5805 }
5806 if !self.dependencies.is_empty() {
5807 struct_ser.serialize_field("dependencies", &self.dependencies)?;
5808 }
5809 struct_ser.end()
5810 }
5811}
5812impl<'de> serde::Deserialize<'de> for CreateTableRequest {
5813 #[allow(deprecated)]
5814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5815 where
5816 D: serde::Deserializer<'de>,
5817 {
5818 const FIELDS: &[&str] = &[
5819 "source",
5820 "materialized_view",
5821 "materializedView",
5822 "fragment_graph",
5823 "fragmentGraph",
5824 "job_type",
5825 "jobType",
5826 "if_not_exists",
5827 "ifNotExists",
5828 "dependencies",
5829 ];
5830
5831 #[allow(clippy::enum_variant_names)]
5832 enum GeneratedField {
5833 Source,
5834 MaterializedView,
5835 FragmentGraph,
5836 JobType,
5837 IfNotExists,
5838 Dependencies,
5839 }
5840 impl<'de> serde::Deserialize<'de> for GeneratedField {
5841 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5842 where
5843 D: serde::Deserializer<'de>,
5844 {
5845 struct GeneratedVisitor;
5846
5847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5848 type Value = GeneratedField;
5849
5850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5851 write!(formatter, "expected one of: {:?}", &FIELDS)
5852 }
5853
5854 #[allow(unused_variables)]
5855 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5856 where
5857 E: serde::de::Error,
5858 {
5859 match value {
5860 "source" => Ok(GeneratedField::Source),
5861 "materializedView" | "materialized_view" => Ok(GeneratedField::MaterializedView),
5862 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
5863 "jobType" | "job_type" => Ok(GeneratedField::JobType),
5864 "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
5865 "dependencies" => Ok(GeneratedField::Dependencies),
5866 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5867 }
5868 }
5869 }
5870 deserializer.deserialize_identifier(GeneratedVisitor)
5871 }
5872 }
5873 struct GeneratedVisitor;
5874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5875 type Value = CreateTableRequest;
5876
5877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5878 formatter.write_str("struct ddl_service.CreateTableRequest")
5879 }
5880
5881 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableRequest, V::Error>
5882 where
5883 V: serde::de::MapAccess<'de>,
5884 {
5885 let mut source__ = None;
5886 let mut materialized_view__ = None;
5887 let mut fragment_graph__ = None;
5888 let mut job_type__ = None;
5889 let mut if_not_exists__ = None;
5890 let mut dependencies__ = None;
5891 while let Some(k) = map_.next_key()? {
5892 match k {
5893 GeneratedField::Source => {
5894 if source__.is_some() {
5895 return Err(serde::de::Error::duplicate_field("source"));
5896 }
5897 source__ = map_.next_value()?;
5898 }
5899 GeneratedField::MaterializedView => {
5900 if materialized_view__.is_some() {
5901 return Err(serde::de::Error::duplicate_field("materializedView"));
5902 }
5903 materialized_view__ = map_.next_value()?;
5904 }
5905 GeneratedField::FragmentGraph => {
5906 if fragment_graph__.is_some() {
5907 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
5908 }
5909 fragment_graph__ = map_.next_value()?;
5910 }
5911 GeneratedField::JobType => {
5912 if job_type__.is_some() {
5913 return Err(serde::de::Error::duplicate_field("jobType"));
5914 }
5915 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
5916 }
5917 GeneratedField::IfNotExists => {
5918 if if_not_exists__.is_some() {
5919 return Err(serde::de::Error::duplicate_field("ifNotExists"));
5920 }
5921 if_not_exists__ = Some(map_.next_value()?);
5922 }
5923 GeneratedField::Dependencies => {
5924 if dependencies__.is_some() {
5925 return Err(serde::de::Error::duplicate_field("dependencies"));
5926 }
5927 dependencies__ =
5928 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5929 .into_iter().map(|x| x.0).collect())
5930 ;
5931 }
5932 }
5933 }
5934 Ok(CreateTableRequest {
5935 source: source__,
5936 materialized_view: materialized_view__,
5937 fragment_graph: fragment_graph__,
5938 job_type: job_type__.unwrap_or_default(),
5939 if_not_exists: if_not_exists__.unwrap_or_default(),
5940 dependencies: dependencies__.unwrap_or_default(),
5941 })
5942 }
5943 }
5944 deserializer.deserialize_struct("ddl_service.CreateTableRequest", FIELDS, GeneratedVisitor)
5945 }
5946}
5947impl serde::Serialize for CreateTableResponse {
5948 #[allow(deprecated)]
5949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5950 where
5951 S: serde::Serializer,
5952 {
5953 use serde::ser::SerializeStruct;
5954 let mut len = 0;
5955 if self.status.is_some() {
5956 len += 1;
5957 }
5958 if self.version.is_some() {
5959 len += 1;
5960 }
5961 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateTableResponse", len)?;
5962 if let Some(v) = self.status.as_ref() {
5963 struct_ser.serialize_field("status", v)?;
5964 }
5965 if let Some(v) = self.version.as_ref() {
5966 struct_ser.serialize_field("version", v)?;
5967 }
5968 struct_ser.end()
5969 }
5970}
5971impl<'de> serde::Deserialize<'de> for CreateTableResponse {
5972 #[allow(deprecated)]
5973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5974 where
5975 D: serde::Deserializer<'de>,
5976 {
5977 const FIELDS: &[&str] = &[
5978 "status",
5979 "version",
5980 ];
5981
5982 #[allow(clippy::enum_variant_names)]
5983 enum GeneratedField {
5984 Status,
5985 Version,
5986 }
5987 impl<'de> serde::Deserialize<'de> for GeneratedField {
5988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5989 where
5990 D: serde::Deserializer<'de>,
5991 {
5992 struct GeneratedVisitor;
5993
5994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5995 type Value = GeneratedField;
5996
5997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5998 write!(formatter, "expected one of: {:?}", &FIELDS)
5999 }
6000
6001 #[allow(unused_variables)]
6002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6003 where
6004 E: serde::de::Error,
6005 {
6006 match value {
6007 "status" => Ok(GeneratedField::Status),
6008 "version" => Ok(GeneratedField::Version),
6009 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6010 }
6011 }
6012 }
6013 deserializer.deserialize_identifier(GeneratedVisitor)
6014 }
6015 }
6016 struct GeneratedVisitor;
6017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6018 type Value = CreateTableResponse;
6019
6020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6021 formatter.write_str("struct ddl_service.CreateTableResponse")
6022 }
6023
6024 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTableResponse, V::Error>
6025 where
6026 V: serde::de::MapAccess<'de>,
6027 {
6028 let mut status__ = None;
6029 let mut version__ = None;
6030 while let Some(k) = map_.next_key()? {
6031 match k {
6032 GeneratedField::Status => {
6033 if status__.is_some() {
6034 return Err(serde::de::Error::duplicate_field("status"));
6035 }
6036 status__ = map_.next_value()?;
6037 }
6038 GeneratedField::Version => {
6039 if version__.is_some() {
6040 return Err(serde::de::Error::duplicate_field("version"));
6041 }
6042 version__ = map_.next_value()?;
6043 }
6044 }
6045 }
6046 Ok(CreateTableResponse {
6047 status: status__,
6048 version: version__,
6049 })
6050 }
6051 }
6052 deserializer.deserialize_struct("ddl_service.CreateTableResponse", FIELDS, GeneratedVisitor)
6053 }
6054}
6055impl serde::Serialize for CreateViewRequest {
6056 #[allow(deprecated)]
6057 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6058 where
6059 S: serde::Serializer,
6060 {
6061 use serde::ser::SerializeStruct;
6062 let mut len = 0;
6063 if self.view.is_some() {
6064 len += 1;
6065 }
6066 if !self.dependencies.is_empty() {
6067 len += 1;
6068 }
6069 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewRequest", len)?;
6070 if let Some(v) = self.view.as_ref() {
6071 struct_ser.serialize_field("view", v)?;
6072 }
6073 if !self.dependencies.is_empty() {
6074 struct_ser.serialize_field("dependencies", &self.dependencies)?;
6075 }
6076 struct_ser.end()
6077 }
6078}
6079impl<'de> serde::Deserialize<'de> for CreateViewRequest {
6080 #[allow(deprecated)]
6081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6082 where
6083 D: serde::Deserializer<'de>,
6084 {
6085 const FIELDS: &[&str] = &[
6086 "view",
6087 "dependencies",
6088 ];
6089
6090 #[allow(clippy::enum_variant_names)]
6091 enum GeneratedField {
6092 View,
6093 Dependencies,
6094 }
6095 impl<'de> serde::Deserialize<'de> for GeneratedField {
6096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6097 where
6098 D: serde::Deserializer<'de>,
6099 {
6100 struct GeneratedVisitor;
6101
6102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6103 type Value = GeneratedField;
6104
6105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6106 write!(formatter, "expected one of: {:?}", &FIELDS)
6107 }
6108
6109 #[allow(unused_variables)]
6110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6111 where
6112 E: serde::de::Error,
6113 {
6114 match value {
6115 "view" => Ok(GeneratedField::View),
6116 "dependencies" => Ok(GeneratedField::Dependencies),
6117 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6118 }
6119 }
6120 }
6121 deserializer.deserialize_identifier(GeneratedVisitor)
6122 }
6123 }
6124 struct GeneratedVisitor;
6125 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6126 type Value = CreateViewRequest;
6127
6128 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6129 formatter.write_str("struct ddl_service.CreateViewRequest")
6130 }
6131
6132 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewRequest, V::Error>
6133 where
6134 V: serde::de::MapAccess<'de>,
6135 {
6136 let mut view__ = None;
6137 let mut dependencies__ = None;
6138 while let Some(k) = map_.next_key()? {
6139 match k {
6140 GeneratedField::View => {
6141 if view__.is_some() {
6142 return Err(serde::de::Error::duplicate_field("view"));
6143 }
6144 view__ = map_.next_value()?;
6145 }
6146 GeneratedField::Dependencies => {
6147 if dependencies__.is_some() {
6148 return Err(serde::de::Error::duplicate_field("dependencies"));
6149 }
6150 dependencies__ =
6151 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6152 .into_iter().map(|x| x.0).collect())
6153 ;
6154 }
6155 }
6156 }
6157 Ok(CreateViewRequest {
6158 view: view__,
6159 dependencies: dependencies__.unwrap_or_default(),
6160 })
6161 }
6162 }
6163 deserializer.deserialize_struct("ddl_service.CreateViewRequest", FIELDS, GeneratedVisitor)
6164 }
6165}
6166impl serde::Serialize for CreateViewResponse {
6167 #[allow(deprecated)]
6168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6169 where
6170 S: serde::Serializer,
6171 {
6172 use serde::ser::SerializeStruct;
6173 let mut len = 0;
6174 if self.status.is_some() {
6175 len += 1;
6176 }
6177 if self.version.is_some() {
6178 len += 1;
6179 }
6180 let mut struct_ser = serializer.serialize_struct("ddl_service.CreateViewResponse", len)?;
6181 if let Some(v) = self.status.as_ref() {
6182 struct_ser.serialize_field("status", v)?;
6183 }
6184 if let Some(v) = self.version.as_ref() {
6185 struct_ser.serialize_field("version", v)?;
6186 }
6187 struct_ser.end()
6188 }
6189}
6190impl<'de> serde::Deserialize<'de> for CreateViewResponse {
6191 #[allow(deprecated)]
6192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6193 where
6194 D: serde::Deserializer<'de>,
6195 {
6196 const FIELDS: &[&str] = &[
6197 "status",
6198 "version",
6199 ];
6200
6201 #[allow(clippy::enum_variant_names)]
6202 enum GeneratedField {
6203 Status,
6204 Version,
6205 }
6206 impl<'de> serde::Deserialize<'de> for GeneratedField {
6207 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6208 where
6209 D: serde::Deserializer<'de>,
6210 {
6211 struct GeneratedVisitor;
6212
6213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6214 type Value = GeneratedField;
6215
6216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6217 write!(formatter, "expected one of: {:?}", &FIELDS)
6218 }
6219
6220 #[allow(unused_variables)]
6221 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6222 where
6223 E: serde::de::Error,
6224 {
6225 match value {
6226 "status" => Ok(GeneratedField::Status),
6227 "version" => Ok(GeneratedField::Version),
6228 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6229 }
6230 }
6231 }
6232 deserializer.deserialize_identifier(GeneratedVisitor)
6233 }
6234 }
6235 struct GeneratedVisitor;
6236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6237 type Value = CreateViewResponse;
6238
6239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6240 formatter.write_str("struct ddl_service.CreateViewResponse")
6241 }
6242
6243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateViewResponse, V::Error>
6244 where
6245 V: serde::de::MapAccess<'de>,
6246 {
6247 let mut status__ = None;
6248 let mut version__ = None;
6249 while let Some(k) = map_.next_key()? {
6250 match k {
6251 GeneratedField::Status => {
6252 if status__.is_some() {
6253 return Err(serde::de::Error::duplicate_field("status"));
6254 }
6255 status__ = map_.next_value()?;
6256 }
6257 GeneratedField::Version => {
6258 if version__.is_some() {
6259 return Err(serde::de::Error::duplicate_field("version"));
6260 }
6261 version__ = map_.next_value()?;
6262 }
6263 }
6264 }
6265 Ok(CreateViewResponse {
6266 status: status__,
6267 version: version__,
6268 })
6269 }
6270 }
6271 deserializer.deserialize_struct("ddl_service.CreateViewResponse", FIELDS, GeneratedVisitor)
6272 }
6273}
6274impl serde::Serialize for DdlProgress {
6275 #[allow(deprecated)]
6276 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6277 where
6278 S: serde::Serializer,
6279 {
6280 use serde::ser::SerializeStruct;
6281 let mut len = 0;
6282 if self.id != 0 {
6283 len += 1;
6284 }
6285 if !self.statement.is_empty() {
6286 len += 1;
6287 }
6288 if !self.progress.is_empty() {
6289 len += 1;
6290 }
6291 if !self.create_type.is_empty() {
6292 len += 1;
6293 }
6294 let mut struct_ser = serializer.serialize_struct("ddl_service.DdlProgress", len)?;
6295 if self.id != 0 {
6296 #[allow(clippy::needless_borrow)]
6297 #[allow(clippy::needless_borrows_for_generic_args)]
6298 struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6299 }
6300 if !self.statement.is_empty() {
6301 struct_ser.serialize_field("statement", &self.statement)?;
6302 }
6303 if !self.progress.is_empty() {
6304 struct_ser.serialize_field("progress", &self.progress)?;
6305 }
6306 if !self.create_type.is_empty() {
6307 struct_ser.serialize_field("createType", &self.create_type)?;
6308 }
6309 struct_ser.end()
6310 }
6311}
6312impl<'de> serde::Deserialize<'de> for DdlProgress {
6313 #[allow(deprecated)]
6314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6315 where
6316 D: serde::Deserializer<'de>,
6317 {
6318 const FIELDS: &[&str] = &[
6319 "id",
6320 "statement",
6321 "progress",
6322 "create_type",
6323 "createType",
6324 ];
6325
6326 #[allow(clippy::enum_variant_names)]
6327 enum GeneratedField {
6328 Id,
6329 Statement,
6330 Progress,
6331 CreateType,
6332 }
6333 impl<'de> serde::Deserialize<'de> for GeneratedField {
6334 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6335 where
6336 D: serde::Deserializer<'de>,
6337 {
6338 struct GeneratedVisitor;
6339
6340 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6341 type Value = GeneratedField;
6342
6343 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6344 write!(formatter, "expected one of: {:?}", &FIELDS)
6345 }
6346
6347 #[allow(unused_variables)]
6348 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6349 where
6350 E: serde::de::Error,
6351 {
6352 match value {
6353 "id" => Ok(GeneratedField::Id),
6354 "statement" => Ok(GeneratedField::Statement),
6355 "progress" => Ok(GeneratedField::Progress),
6356 "createType" | "create_type" => Ok(GeneratedField::CreateType),
6357 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6358 }
6359 }
6360 }
6361 deserializer.deserialize_identifier(GeneratedVisitor)
6362 }
6363 }
6364 struct GeneratedVisitor;
6365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6366 type Value = DdlProgress;
6367
6368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6369 formatter.write_str("struct ddl_service.DdlProgress")
6370 }
6371
6372 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DdlProgress, V::Error>
6373 where
6374 V: serde::de::MapAccess<'de>,
6375 {
6376 let mut id__ = None;
6377 let mut statement__ = None;
6378 let mut progress__ = None;
6379 let mut create_type__ = None;
6380 while let Some(k) = map_.next_key()? {
6381 match k {
6382 GeneratedField::Id => {
6383 if id__.is_some() {
6384 return Err(serde::de::Error::duplicate_field("id"));
6385 }
6386 id__ =
6387 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6388 ;
6389 }
6390 GeneratedField::Statement => {
6391 if statement__.is_some() {
6392 return Err(serde::de::Error::duplicate_field("statement"));
6393 }
6394 statement__ = Some(map_.next_value()?);
6395 }
6396 GeneratedField::Progress => {
6397 if progress__.is_some() {
6398 return Err(serde::de::Error::duplicate_field("progress"));
6399 }
6400 progress__ = Some(map_.next_value()?);
6401 }
6402 GeneratedField::CreateType => {
6403 if create_type__.is_some() {
6404 return Err(serde::de::Error::duplicate_field("createType"));
6405 }
6406 create_type__ = Some(map_.next_value()?);
6407 }
6408 }
6409 }
6410 Ok(DdlProgress {
6411 id: id__.unwrap_or_default(),
6412 statement: statement__.unwrap_or_default(),
6413 progress: progress__.unwrap_or_default(),
6414 create_type: create_type__.unwrap_or_default(),
6415 })
6416 }
6417 }
6418 deserializer.deserialize_struct("ddl_service.DdlProgress", FIELDS, GeneratedVisitor)
6419 }
6420}
6421impl serde::Serialize for DropConnectionRequest {
6422 #[allow(deprecated)]
6423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6424 where
6425 S: serde::Serializer,
6426 {
6427 use serde::ser::SerializeStruct;
6428 let mut len = 0;
6429 if self.connection_id != 0 {
6430 len += 1;
6431 }
6432 if self.cascade {
6433 len += 1;
6434 }
6435 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionRequest", len)?;
6436 if self.connection_id != 0 {
6437 struct_ser.serialize_field("connectionId", &self.connection_id)?;
6438 }
6439 if self.cascade {
6440 struct_ser.serialize_field("cascade", &self.cascade)?;
6441 }
6442 struct_ser.end()
6443 }
6444}
6445impl<'de> serde::Deserialize<'de> for DropConnectionRequest {
6446 #[allow(deprecated)]
6447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6448 where
6449 D: serde::Deserializer<'de>,
6450 {
6451 const FIELDS: &[&str] = &[
6452 "connection_id",
6453 "connectionId",
6454 "cascade",
6455 ];
6456
6457 #[allow(clippy::enum_variant_names)]
6458 enum GeneratedField {
6459 ConnectionId,
6460 Cascade,
6461 }
6462 impl<'de> serde::Deserialize<'de> for GeneratedField {
6463 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6464 where
6465 D: serde::Deserializer<'de>,
6466 {
6467 struct GeneratedVisitor;
6468
6469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6470 type Value = GeneratedField;
6471
6472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6473 write!(formatter, "expected one of: {:?}", &FIELDS)
6474 }
6475
6476 #[allow(unused_variables)]
6477 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6478 where
6479 E: serde::de::Error,
6480 {
6481 match value {
6482 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
6483 "cascade" => Ok(GeneratedField::Cascade),
6484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6485 }
6486 }
6487 }
6488 deserializer.deserialize_identifier(GeneratedVisitor)
6489 }
6490 }
6491 struct GeneratedVisitor;
6492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6493 type Value = DropConnectionRequest;
6494
6495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6496 formatter.write_str("struct ddl_service.DropConnectionRequest")
6497 }
6498
6499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionRequest, V::Error>
6500 where
6501 V: serde::de::MapAccess<'de>,
6502 {
6503 let mut connection_id__ = None;
6504 let mut cascade__ = None;
6505 while let Some(k) = map_.next_key()? {
6506 match k {
6507 GeneratedField::ConnectionId => {
6508 if connection_id__.is_some() {
6509 return Err(serde::de::Error::duplicate_field("connectionId"));
6510 }
6511 connection_id__ =
6512 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6513 ;
6514 }
6515 GeneratedField::Cascade => {
6516 if cascade__.is_some() {
6517 return Err(serde::de::Error::duplicate_field("cascade"));
6518 }
6519 cascade__ = Some(map_.next_value()?);
6520 }
6521 }
6522 }
6523 Ok(DropConnectionRequest {
6524 connection_id: connection_id__.unwrap_or_default(),
6525 cascade: cascade__.unwrap_or_default(),
6526 })
6527 }
6528 }
6529 deserializer.deserialize_struct("ddl_service.DropConnectionRequest", FIELDS, GeneratedVisitor)
6530 }
6531}
6532impl serde::Serialize for DropConnectionResponse {
6533 #[allow(deprecated)]
6534 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6535 where
6536 S: serde::Serializer,
6537 {
6538 use serde::ser::SerializeStruct;
6539 let mut len = 0;
6540 if self.status.is_some() {
6541 len += 1;
6542 }
6543 if self.version.is_some() {
6544 len += 1;
6545 }
6546 let mut struct_ser = serializer.serialize_struct("ddl_service.DropConnectionResponse", len)?;
6547 if let Some(v) = self.status.as_ref() {
6548 struct_ser.serialize_field("status", v)?;
6549 }
6550 if let Some(v) = self.version.as_ref() {
6551 struct_ser.serialize_field("version", v)?;
6552 }
6553 struct_ser.end()
6554 }
6555}
6556impl<'de> serde::Deserialize<'de> for DropConnectionResponse {
6557 #[allow(deprecated)]
6558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6559 where
6560 D: serde::Deserializer<'de>,
6561 {
6562 const FIELDS: &[&str] = &[
6563 "status",
6564 "version",
6565 ];
6566
6567 #[allow(clippy::enum_variant_names)]
6568 enum GeneratedField {
6569 Status,
6570 Version,
6571 }
6572 impl<'de> serde::Deserialize<'de> for GeneratedField {
6573 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6574 where
6575 D: serde::Deserializer<'de>,
6576 {
6577 struct GeneratedVisitor;
6578
6579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6580 type Value = GeneratedField;
6581
6582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6583 write!(formatter, "expected one of: {:?}", &FIELDS)
6584 }
6585
6586 #[allow(unused_variables)]
6587 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6588 where
6589 E: serde::de::Error,
6590 {
6591 match value {
6592 "status" => Ok(GeneratedField::Status),
6593 "version" => Ok(GeneratedField::Version),
6594 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6595 }
6596 }
6597 }
6598 deserializer.deserialize_identifier(GeneratedVisitor)
6599 }
6600 }
6601 struct GeneratedVisitor;
6602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6603 type Value = DropConnectionResponse;
6604
6605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6606 formatter.write_str("struct ddl_service.DropConnectionResponse")
6607 }
6608
6609 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropConnectionResponse, V::Error>
6610 where
6611 V: serde::de::MapAccess<'de>,
6612 {
6613 let mut status__ = None;
6614 let mut version__ = None;
6615 while let Some(k) = map_.next_key()? {
6616 match k {
6617 GeneratedField::Status => {
6618 if status__.is_some() {
6619 return Err(serde::de::Error::duplicate_field("status"));
6620 }
6621 status__ = map_.next_value()?;
6622 }
6623 GeneratedField::Version => {
6624 if version__.is_some() {
6625 return Err(serde::de::Error::duplicate_field("version"));
6626 }
6627 version__ = map_.next_value()?;
6628 }
6629 }
6630 }
6631 Ok(DropConnectionResponse {
6632 status: status__,
6633 version: version__,
6634 })
6635 }
6636 }
6637 deserializer.deserialize_struct("ddl_service.DropConnectionResponse", FIELDS, GeneratedVisitor)
6638 }
6639}
6640impl serde::Serialize for DropDatabaseRequest {
6641 #[allow(deprecated)]
6642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6643 where
6644 S: serde::Serializer,
6645 {
6646 use serde::ser::SerializeStruct;
6647 let mut len = 0;
6648 if self.database_id != 0 {
6649 len += 1;
6650 }
6651 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseRequest", len)?;
6652 if self.database_id != 0 {
6653 struct_ser.serialize_field("databaseId", &self.database_id)?;
6654 }
6655 struct_ser.end()
6656 }
6657}
6658impl<'de> serde::Deserialize<'de> for DropDatabaseRequest {
6659 #[allow(deprecated)]
6660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6661 where
6662 D: serde::Deserializer<'de>,
6663 {
6664 const FIELDS: &[&str] = &[
6665 "database_id",
6666 "databaseId",
6667 ];
6668
6669 #[allow(clippy::enum_variant_names)]
6670 enum GeneratedField {
6671 DatabaseId,
6672 }
6673 impl<'de> serde::Deserialize<'de> for GeneratedField {
6674 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6675 where
6676 D: serde::Deserializer<'de>,
6677 {
6678 struct GeneratedVisitor;
6679
6680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6681 type Value = GeneratedField;
6682
6683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6684 write!(formatter, "expected one of: {:?}", &FIELDS)
6685 }
6686
6687 #[allow(unused_variables)]
6688 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6689 where
6690 E: serde::de::Error,
6691 {
6692 match value {
6693 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6695 }
6696 }
6697 }
6698 deserializer.deserialize_identifier(GeneratedVisitor)
6699 }
6700 }
6701 struct GeneratedVisitor;
6702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6703 type Value = DropDatabaseRequest;
6704
6705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6706 formatter.write_str("struct ddl_service.DropDatabaseRequest")
6707 }
6708
6709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseRequest, V::Error>
6710 where
6711 V: serde::de::MapAccess<'de>,
6712 {
6713 let mut database_id__ = None;
6714 while let Some(k) = map_.next_key()? {
6715 match k {
6716 GeneratedField::DatabaseId => {
6717 if database_id__.is_some() {
6718 return Err(serde::de::Error::duplicate_field("databaseId"));
6719 }
6720 database_id__ =
6721 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6722 ;
6723 }
6724 }
6725 }
6726 Ok(DropDatabaseRequest {
6727 database_id: database_id__.unwrap_or_default(),
6728 })
6729 }
6730 }
6731 deserializer.deserialize_struct("ddl_service.DropDatabaseRequest", FIELDS, GeneratedVisitor)
6732 }
6733}
6734impl serde::Serialize for DropDatabaseResponse {
6735 #[allow(deprecated)]
6736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6737 where
6738 S: serde::Serializer,
6739 {
6740 use serde::ser::SerializeStruct;
6741 let mut len = 0;
6742 if self.status.is_some() {
6743 len += 1;
6744 }
6745 if self.version.is_some() {
6746 len += 1;
6747 }
6748 let mut struct_ser = serializer.serialize_struct("ddl_service.DropDatabaseResponse", len)?;
6749 if let Some(v) = self.status.as_ref() {
6750 struct_ser.serialize_field("status", v)?;
6751 }
6752 if let Some(v) = self.version.as_ref() {
6753 struct_ser.serialize_field("version", v)?;
6754 }
6755 struct_ser.end()
6756 }
6757}
6758impl<'de> serde::Deserialize<'de> for DropDatabaseResponse {
6759 #[allow(deprecated)]
6760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6761 where
6762 D: serde::Deserializer<'de>,
6763 {
6764 const FIELDS: &[&str] = &[
6765 "status",
6766 "version",
6767 ];
6768
6769 #[allow(clippy::enum_variant_names)]
6770 enum GeneratedField {
6771 Status,
6772 Version,
6773 }
6774 impl<'de> serde::Deserialize<'de> for GeneratedField {
6775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6776 where
6777 D: serde::Deserializer<'de>,
6778 {
6779 struct GeneratedVisitor;
6780
6781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6782 type Value = GeneratedField;
6783
6784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6785 write!(formatter, "expected one of: {:?}", &FIELDS)
6786 }
6787
6788 #[allow(unused_variables)]
6789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6790 where
6791 E: serde::de::Error,
6792 {
6793 match value {
6794 "status" => Ok(GeneratedField::Status),
6795 "version" => Ok(GeneratedField::Version),
6796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6797 }
6798 }
6799 }
6800 deserializer.deserialize_identifier(GeneratedVisitor)
6801 }
6802 }
6803 struct GeneratedVisitor;
6804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6805 type Value = DropDatabaseResponse;
6806
6807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6808 formatter.write_str("struct ddl_service.DropDatabaseResponse")
6809 }
6810
6811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropDatabaseResponse, V::Error>
6812 where
6813 V: serde::de::MapAccess<'de>,
6814 {
6815 let mut status__ = None;
6816 let mut version__ = None;
6817 while let Some(k) = map_.next_key()? {
6818 match k {
6819 GeneratedField::Status => {
6820 if status__.is_some() {
6821 return Err(serde::de::Error::duplicate_field("status"));
6822 }
6823 status__ = map_.next_value()?;
6824 }
6825 GeneratedField::Version => {
6826 if version__.is_some() {
6827 return Err(serde::de::Error::duplicate_field("version"));
6828 }
6829 version__ = map_.next_value()?;
6830 }
6831 }
6832 }
6833 Ok(DropDatabaseResponse {
6834 status: status__,
6835 version: version__,
6836 })
6837 }
6838 }
6839 deserializer.deserialize_struct("ddl_service.DropDatabaseResponse", FIELDS, GeneratedVisitor)
6840 }
6841}
6842impl serde::Serialize for DropFunctionRequest {
6843 #[allow(deprecated)]
6844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6845 where
6846 S: serde::Serializer,
6847 {
6848 use serde::ser::SerializeStruct;
6849 let mut len = 0;
6850 if self.function_id != 0 {
6851 len += 1;
6852 }
6853 if self.cascade {
6854 len += 1;
6855 }
6856 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionRequest", len)?;
6857 if self.function_id != 0 {
6858 struct_ser.serialize_field("functionId", &self.function_id)?;
6859 }
6860 if self.cascade {
6861 struct_ser.serialize_field("cascade", &self.cascade)?;
6862 }
6863 struct_ser.end()
6864 }
6865}
6866impl<'de> serde::Deserialize<'de> for DropFunctionRequest {
6867 #[allow(deprecated)]
6868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6869 where
6870 D: serde::Deserializer<'de>,
6871 {
6872 const FIELDS: &[&str] = &[
6873 "function_id",
6874 "functionId",
6875 "cascade",
6876 ];
6877
6878 #[allow(clippy::enum_variant_names)]
6879 enum GeneratedField {
6880 FunctionId,
6881 Cascade,
6882 }
6883 impl<'de> serde::Deserialize<'de> for GeneratedField {
6884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6885 where
6886 D: serde::Deserializer<'de>,
6887 {
6888 struct GeneratedVisitor;
6889
6890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6891 type Value = GeneratedField;
6892
6893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6894 write!(formatter, "expected one of: {:?}", &FIELDS)
6895 }
6896
6897 #[allow(unused_variables)]
6898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6899 where
6900 E: serde::de::Error,
6901 {
6902 match value {
6903 "functionId" | "function_id" => Ok(GeneratedField::FunctionId),
6904 "cascade" => Ok(GeneratedField::Cascade),
6905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6906 }
6907 }
6908 }
6909 deserializer.deserialize_identifier(GeneratedVisitor)
6910 }
6911 }
6912 struct GeneratedVisitor;
6913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6914 type Value = DropFunctionRequest;
6915
6916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6917 formatter.write_str("struct ddl_service.DropFunctionRequest")
6918 }
6919
6920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionRequest, V::Error>
6921 where
6922 V: serde::de::MapAccess<'de>,
6923 {
6924 let mut function_id__ = None;
6925 let mut cascade__ = None;
6926 while let Some(k) = map_.next_key()? {
6927 match k {
6928 GeneratedField::FunctionId => {
6929 if function_id__.is_some() {
6930 return Err(serde::de::Error::duplicate_field("functionId"));
6931 }
6932 function_id__ =
6933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6934 ;
6935 }
6936 GeneratedField::Cascade => {
6937 if cascade__.is_some() {
6938 return Err(serde::de::Error::duplicate_field("cascade"));
6939 }
6940 cascade__ = Some(map_.next_value()?);
6941 }
6942 }
6943 }
6944 Ok(DropFunctionRequest {
6945 function_id: function_id__.unwrap_or_default(),
6946 cascade: cascade__.unwrap_or_default(),
6947 })
6948 }
6949 }
6950 deserializer.deserialize_struct("ddl_service.DropFunctionRequest", FIELDS, GeneratedVisitor)
6951 }
6952}
6953impl serde::Serialize for DropFunctionResponse {
6954 #[allow(deprecated)]
6955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6956 where
6957 S: serde::Serializer,
6958 {
6959 use serde::ser::SerializeStruct;
6960 let mut len = 0;
6961 if self.status.is_some() {
6962 len += 1;
6963 }
6964 if self.version.is_some() {
6965 len += 1;
6966 }
6967 let mut struct_ser = serializer.serialize_struct("ddl_service.DropFunctionResponse", len)?;
6968 if let Some(v) = self.status.as_ref() {
6969 struct_ser.serialize_field("status", v)?;
6970 }
6971 if let Some(v) = self.version.as_ref() {
6972 struct_ser.serialize_field("version", v)?;
6973 }
6974 struct_ser.end()
6975 }
6976}
6977impl<'de> serde::Deserialize<'de> for DropFunctionResponse {
6978 #[allow(deprecated)]
6979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6980 where
6981 D: serde::Deserializer<'de>,
6982 {
6983 const FIELDS: &[&str] = &[
6984 "status",
6985 "version",
6986 ];
6987
6988 #[allow(clippy::enum_variant_names)]
6989 enum GeneratedField {
6990 Status,
6991 Version,
6992 }
6993 impl<'de> serde::Deserialize<'de> for GeneratedField {
6994 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6995 where
6996 D: serde::Deserializer<'de>,
6997 {
6998 struct GeneratedVisitor;
6999
7000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7001 type Value = GeneratedField;
7002
7003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7004 write!(formatter, "expected one of: {:?}", &FIELDS)
7005 }
7006
7007 #[allow(unused_variables)]
7008 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7009 where
7010 E: serde::de::Error,
7011 {
7012 match value {
7013 "status" => Ok(GeneratedField::Status),
7014 "version" => Ok(GeneratedField::Version),
7015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7016 }
7017 }
7018 }
7019 deserializer.deserialize_identifier(GeneratedVisitor)
7020 }
7021 }
7022 struct GeneratedVisitor;
7023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7024 type Value = DropFunctionResponse;
7025
7026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7027 formatter.write_str("struct ddl_service.DropFunctionResponse")
7028 }
7029
7030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropFunctionResponse, V::Error>
7031 where
7032 V: serde::de::MapAccess<'de>,
7033 {
7034 let mut status__ = None;
7035 let mut version__ = None;
7036 while let Some(k) = map_.next_key()? {
7037 match k {
7038 GeneratedField::Status => {
7039 if status__.is_some() {
7040 return Err(serde::de::Error::duplicate_field("status"));
7041 }
7042 status__ = map_.next_value()?;
7043 }
7044 GeneratedField::Version => {
7045 if version__.is_some() {
7046 return Err(serde::de::Error::duplicate_field("version"));
7047 }
7048 version__ = map_.next_value()?;
7049 }
7050 }
7051 }
7052 Ok(DropFunctionResponse {
7053 status: status__,
7054 version: version__,
7055 })
7056 }
7057 }
7058 deserializer.deserialize_struct("ddl_service.DropFunctionResponse", FIELDS, GeneratedVisitor)
7059 }
7060}
7061impl serde::Serialize for DropIndexRequest {
7062 #[allow(deprecated)]
7063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7064 where
7065 S: serde::Serializer,
7066 {
7067 use serde::ser::SerializeStruct;
7068 let mut len = 0;
7069 if self.index_id != 0 {
7070 len += 1;
7071 }
7072 if self.cascade {
7073 len += 1;
7074 }
7075 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexRequest", len)?;
7076 if self.index_id != 0 {
7077 struct_ser.serialize_field("indexId", &self.index_id)?;
7078 }
7079 if self.cascade {
7080 struct_ser.serialize_field("cascade", &self.cascade)?;
7081 }
7082 struct_ser.end()
7083 }
7084}
7085impl<'de> serde::Deserialize<'de> for DropIndexRequest {
7086 #[allow(deprecated)]
7087 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7088 where
7089 D: serde::Deserializer<'de>,
7090 {
7091 const FIELDS: &[&str] = &[
7092 "index_id",
7093 "indexId",
7094 "cascade",
7095 ];
7096
7097 #[allow(clippy::enum_variant_names)]
7098 enum GeneratedField {
7099 IndexId,
7100 Cascade,
7101 }
7102 impl<'de> serde::Deserialize<'de> for GeneratedField {
7103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7104 where
7105 D: serde::Deserializer<'de>,
7106 {
7107 struct GeneratedVisitor;
7108
7109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7110 type Value = GeneratedField;
7111
7112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7113 write!(formatter, "expected one of: {:?}", &FIELDS)
7114 }
7115
7116 #[allow(unused_variables)]
7117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7118 where
7119 E: serde::de::Error,
7120 {
7121 match value {
7122 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7123 "cascade" => Ok(GeneratedField::Cascade),
7124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7125 }
7126 }
7127 }
7128 deserializer.deserialize_identifier(GeneratedVisitor)
7129 }
7130 }
7131 struct GeneratedVisitor;
7132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7133 type Value = DropIndexRequest;
7134
7135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7136 formatter.write_str("struct ddl_service.DropIndexRequest")
7137 }
7138
7139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexRequest, V::Error>
7140 where
7141 V: serde::de::MapAccess<'de>,
7142 {
7143 let mut index_id__ = None;
7144 let mut cascade__ = None;
7145 while let Some(k) = map_.next_key()? {
7146 match k {
7147 GeneratedField::IndexId => {
7148 if index_id__.is_some() {
7149 return Err(serde::de::Error::duplicate_field("indexId"));
7150 }
7151 index_id__ =
7152 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7153 ;
7154 }
7155 GeneratedField::Cascade => {
7156 if cascade__.is_some() {
7157 return Err(serde::de::Error::duplicate_field("cascade"));
7158 }
7159 cascade__ = Some(map_.next_value()?);
7160 }
7161 }
7162 }
7163 Ok(DropIndexRequest {
7164 index_id: index_id__.unwrap_or_default(),
7165 cascade: cascade__.unwrap_or_default(),
7166 })
7167 }
7168 }
7169 deserializer.deserialize_struct("ddl_service.DropIndexRequest", FIELDS, GeneratedVisitor)
7170 }
7171}
7172impl serde::Serialize for DropIndexResponse {
7173 #[allow(deprecated)]
7174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7175 where
7176 S: serde::Serializer,
7177 {
7178 use serde::ser::SerializeStruct;
7179 let mut len = 0;
7180 if self.status.is_some() {
7181 len += 1;
7182 }
7183 if self.version.is_some() {
7184 len += 1;
7185 }
7186 let mut struct_ser = serializer.serialize_struct("ddl_service.DropIndexResponse", len)?;
7187 if let Some(v) = self.status.as_ref() {
7188 struct_ser.serialize_field("status", v)?;
7189 }
7190 if let Some(v) = self.version.as_ref() {
7191 struct_ser.serialize_field("version", v)?;
7192 }
7193 struct_ser.end()
7194 }
7195}
7196impl<'de> serde::Deserialize<'de> for DropIndexResponse {
7197 #[allow(deprecated)]
7198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7199 where
7200 D: serde::Deserializer<'de>,
7201 {
7202 const FIELDS: &[&str] = &[
7203 "status",
7204 "version",
7205 ];
7206
7207 #[allow(clippy::enum_variant_names)]
7208 enum GeneratedField {
7209 Status,
7210 Version,
7211 }
7212 impl<'de> serde::Deserialize<'de> for GeneratedField {
7213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7214 where
7215 D: serde::Deserializer<'de>,
7216 {
7217 struct GeneratedVisitor;
7218
7219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7220 type Value = GeneratedField;
7221
7222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7223 write!(formatter, "expected one of: {:?}", &FIELDS)
7224 }
7225
7226 #[allow(unused_variables)]
7227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7228 where
7229 E: serde::de::Error,
7230 {
7231 match value {
7232 "status" => Ok(GeneratedField::Status),
7233 "version" => Ok(GeneratedField::Version),
7234 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7235 }
7236 }
7237 }
7238 deserializer.deserialize_identifier(GeneratedVisitor)
7239 }
7240 }
7241 struct GeneratedVisitor;
7242 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7243 type Value = DropIndexResponse;
7244
7245 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7246 formatter.write_str("struct ddl_service.DropIndexResponse")
7247 }
7248
7249 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropIndexResponse, V::Error>
7250 where
7251 V: serde::de::MapAccess<'de>,
7252 {
7253 let mut status__ = None;
7254 let mut version__ = None;
7255 while let Some(k) = map_.next_key()? {
7256 match k {
7257 GeneratedField::Status => {
7258 if status__.is_some() {
7259 return Err(serde::de::Error::duplicate_field("status"));
7260 }
7261 status__ = map_.next_value()?;
7262 }
7263 GeneratedField::Version => {
7264 if version__.is_some() {
7265 return Err(serde::de::Error::duplicate_field("version"));
7266 }
7267 version__ = map_.next_value()?;
7268 }
7269 }
7270 }
7271 Ok(DropIndexResponse {
7272 status: status__,
7273 version: version__,
7274 })
7275 }
7276 }
7277 deserializer.deserialize_struct("ddl_service.DropIndexResponse", FIELDS, GeneratedVisitor)
7278 }
7279}
7280impl serde::Serialize for DropMaterializedViewRequest {
7281 #[allow(deprecated)]
7282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7283 where
7284 S: serde::Serializer,
7285 {
7286 use serde::ser::SerializeStruct;
7287 let mut len = 0;
7288 if self.table_id != 0 {
7289 len += 1;
7290 }
7291 if self.cascade {
7292 len += 1;
7293 }
7294 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewRequest", len)?;
7295 if self.table_id != 0 {
7296 struct_ser.serialize_field("tableId", &self.table_id)?;
7297 }
7298 if self.cascade {
7299 struct_ser.serialize_field("cascade", &self.cascade)?;
7300 }
7301 struct_ser.end()
7302 }
7303}
7304impl<'de> serde::Deserialize<'de> for DropMaterializedViewRequest {
7305 #[allow(deprecated)]
7306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7307 where
7308 D: serde::Deserializer<'de>,
7309 {
7310 const FIELDS: &[&str] = &[
7311 "table_id",
7312 "tableId",
7313 "cascade",
7314 ];
7315
7316 #[allow(clippy::enum_variant_names)]
7317 enum GeneratedField {
7318 TableId,
7319 Cascade,
7320 }
7321 impl<'de> serde::Deserialize<'de> for GeneratedField {
7322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7323 where
7324 D: serde::Deserializer<'de>,
7325 {
7326 struct GeneratedVisitor;
7327
7328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7329 type Value = GeneratedField;
7330
7331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7332 write!(formatter, "expected one of: {:?}", &FIELDS)
7333 }
7334
7335 #[allow(unused_variables)]
7336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7337 where
7338 E: serde::de::Error,
7339 {
7340 match value {
7341 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7342 "cascade" => Ok(GeneratedField::Cascade),
7343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7344 }
7345 }
7346 }
7347 deserializer.deserialize_identifier(GeneratedVisitor)
7348 }
7349 }
7350 struct GeneratedVisitor;
7351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7352 type Value = DropMaterializedViewRequest;
7353
7354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7355 formatter.write_str("struct ddl_service.DropMaterializedViewRequest")
7356 }
7357
7358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewRequest, V::Error>
7359 where
7360 V: serde::de::MapAccess<'de>,
7361 {
7362 let mut table_id__ = None;
7363 let mut cascade__ = None;
7364 while let Some(k) = map_.next_key()? {
7365 match k {
7366 GeneratedField::TableId => {
7367 if table_id__.is_some() {
7368 return Err(serde::de::Error::duplicate_field("tableId"));
7369 }
7370 table_id__ =
7371 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7372 ;
7373 }
7374 GeneratedField::Cascade => {
7375 if cascade__.is_some() {
7376 return Err(serde::de::Error::duplicate_field("cascade"));
7377 }
7378 cascade__ = Some(map_.next_value()?);
7379 }
7380 }
7381 }
7382 Ok(DropMaterializedViewRequest {
7383 table_id: table_id__.unwrap_or_default(),
7384 cascade: cascade__.unwrap_or_default(),
7385 })
7386 }
7387 }
7388 deserializer.deserialize_struct("ddl_service.DropMaterializedViewRequest", FIELDS, GeneratedVisitor)
7389 }
7390}
7391impl serde::Serialize for DropMaterializedViewResponse {
7392 #[allow(deprecated)]
7393 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7394 where
7395 S: serde::Serializer,
7396 {
7397 use serde::ser::SerializeStruct;
7398 let mut len = 0;
7399 if self.status.is_some() {
7400 len += 1;
7401 }
7402 if self.version.is_some() {
7403 len += 1;
7404 }
7405 let mut struct_ser = serializer.serialize_struct("ddl_service.DropMaterializedViewResponse", len)?;
7406 if let Some(v) = self.status.as_ref() {
7407 struct_ser.serialize_field("status", v)?;
7408 }
7409 if let Some(v) = self.version.as_ref() {
7410 struct_ser.serialize_field("version", v)?;
7411 }
7412 struct_ser.end()
7413 }
7414}
7415impl<'de> serde::Deserialize<'de> for DropMaterializedViewResponse {
7416 #[allow(deprecated)]
7417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7418 where
7419 D: serde::Deserializer<'de>,
7420 {
7421 const FIELDS: &[&str] = &[
7422 "status",
7423 "version",
7424 ];
7425
7426 #[allow(clippy::enum_variant_names)]
7427 enum GeneratedField {
7428 Status,
7429 Version,
7430 }
7431 impl<'de> serde::Deserialize<'de> for GeneratedField {
7432 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7433 where
7434 D: serde::Deserializer<'de>,
7435 {
7436 struct GeneratedVisitor;
7437
7438 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7439 type Value = GeneratedField;
7440
7441 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7442 write!(formatter, "expected one of: {:?}", &FIELDS)
7443 }
7444
7445 #[allow(unused_variables)]
7446 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7447 where
7448 E: serde::de::Error,
7449 {
7450 match value {
7451 "status" => Ok(GeneratedField::Status),
7452 "version" => Ok(GeneratedField::Version),
7453 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7454 }
7455 }
7456 }
7457 deserializer.deserialize_identifier(GeneratedVisitor)
7458 }
7459 }
7460 struct GeneratedVisitor;
7461 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7462 type Value = DropMaterializedViewResponse;
7463
7464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7465 formatter.write_str("struct ddl_service.DropMaterializedViewResponse")
7466 }
7467
7468 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropMaterializedViewResponse, V::Error>
7469 where
7470 V: serde::de::MapAccess<'de>,
7471 {
7472 let mut status__ = None;
7473 let mut version__ = None;
7474 while let Some(k) = map_.next_key()? {
7475 match k {
7476 GeneratedField::Status => {
7477 if status__.is_some() {
7478 return Err(serde::de::Error::duplicate_field("status"));
7479 }
7480 status__ = map_.next_value()?;
7481 }
7482 GeneratedField::Version => {
7483 if version__.is_some() {
7484 return Err(serde::de::Error::duplicate_field("version"));
7485 }
7486 version__ = map_.next_value()?;
7487 }
7488 }
7489 }
7490 Ok(DropMaterializedViewResponse {
7491 status: status__,
7492 version: version__,
7493 })
7494 }
7495 }
7496 deserializer.deserialize_struct("ddl_service.DropMaterializedViewResponse", FIELDS, GeneratedVisitor)
7497 }
7498}
7499impl serde::Serialize for DropSchemaRequest {
7500 #[allow(deprecated)]
7501 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7502 where
7503 S: serde::Serializer,
7504 {
7505 use serde::ser::SerializeStruct;
7506 let mut len = 0;
7507 if self.schema_id != 0 {
7508 len += 1;
7509 }
7510 if self.cascade {
7511 len += 1;
7512 }
7513 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaRequest", len)?;
7514 if self.schema_id != 0 {
7515 struct_ser.serialize_field("schemaId", &self.schema_id)?;
7516 }
7517 if self.cascade {
7518 struct_ser.serialize_field("cascade", &self.cascade)?;
7519 }
7520 struct_ser.end()
7521 }
7522}
7523impl<'de> serde::Deserialize<'de> for DropSchemaRequest {
7524 #[allow(deprecated)]
7525 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7526 where
7527 D: serde::Deserializer<'de>,
7528 {
7529 const FIELDS: &[&str] = &[
7530 "schema_id",
7531 "schemaId",
7532 "cascade",
7533 ];
7534
7535 #[allow(clippy::enum_variant_names)]
7536 enum GeneratedField {
7537 SchemaId,
7538 Cascade,
7539 }
7540 impl<'de> serde::Deserialize<'de> for GeneratedField {
7541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7542 where
7543 D: serde::Deserializer<'de>,
7544 {
7545 struct GeneratedVisitor;
7546
7547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7548 type Value = GeneratedField;
7549
7550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7551 write!(formatter, "expected one of: {:?}", &FIELDS)
7552 }
7553
7554 #[allow(unused_variables)]
7555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7556 where
7557 E: serde::de::Error,
7558 {
7559 match value {
7560 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
7561 "cascade" => Ok(GeneratedField::Cascade),
7562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7563 }
7564 }
7565 }
7566 deserializer.deserialize_identifier(GeneratedVisitor)
7567 }
7568 }
7569 struct GeneratedVisitor;
7570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7571 type Value = DropSchemaRequest;
7572
7573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7574 formatter.write_str("struct ddl_service.DropSchemaRequest")
7575 }
7576
7577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaRequest, V::Error>
7578 where
7579 V: serde::de::MapAccess<'de>,
7580 {
7581 let mut schema_id__ = None;
7582 let mut cascade__ = None;
7583 while let Some(k) = map_.next_key()? {
7584 match k {
7585 GeneratedField::SchemaId => {
7586 if schema_id__.is_some() {
7587 return Err(serde::de::Error::duplicate_field("schemaId"));
7588 }
7589 schema_id__ =
7590 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7591 ;
7592 }
7593 GeneratedField::Cascade => {
7594 if cascade__.is_some() {
7595 return Err(serde::de::Error::duplicate_field("cascade"));
7596 }
7597 cascade__ = Some(map_.next_value()?);
7598 }
7599 }
7600 }
7601 Ok(DropSchemaRequest {
7602 schema_id: schema_id__.unwrap_or_default(),
7603 cascade: cascade__.unwrap_or_default(),
7604 })
7605 }
7606 }
7607 deserializer.deserialize_struct("ddl_service.DropSchemaRequest", FIELDS, GeneratedVisitor)
7608 }
7609}
7610impl serde::Serialize for DropSchemaResponse {
7611 #[allow(deprecated)]
7612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7613 where
7614 S: serde::Serializer,
7615 {
7616 use serde::ser::SerializeStruct;
7617 let mut len = 0;
7618 if self.status.is_some() {
7619 len += 1;
7620 }
7621 if self.version.is_some() {
7622 len += 1;
7623 }
7624 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSchemaResponse", len)?;
7625 if let Some(v) = self.status.as_ref() {
7626 struct_ser.serialize_field("status", v)?;
7627 }
7628 if let Some(v) = self.version.as_ref() {
7629 struct_ser.serialize_field("version", v)?;
7630 }
7631 struct_ser.end()
7632 }
7633}
7634impl<'de> serde::Deserialize<'de> for DropSchemaResponse {
7635 #[allow(deprecated)]
7636 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7637 where
7638 D: serde::Deserializer<'de>,
7639 {
7640 const FIELDS: &[&str] = &[
7641 "status",
7642 "version",
7643 ];
7644
7645 #[allow(clippy::enum_variant_names)]
7646 enum GeneratedField {
7647 Status,
7648 Version,
7649 }
7650 impl<'de> serde::Deserialize<'de> for GeneratedField {
7651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7652 where
7653 D: serde::Deserializer<'de>,
7654 {
7655 struct GeneratedVisitor;
7656
7657 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7658 type Value = GeneratedField;
7659
7660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7661 write!(formatter, "expected one of: {:?}", &FIELDS)
7662 }
7663
7664 #[allow(unused_variables)]
7665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7666 where
7667 E: serde::de::Error,
7668 {
7669 match value {
7670 "status" => Ok(GeneratedField::Status),
7671 "version" => Ok(GeneratedField::Version),
7672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7673 }
7674 }
7675 }
7676 deserializer.deserialize_identifier(GeneratedVisitor)
7677 }
7678 }
7679 struct GeneratedVisitor;
7680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7681 type Value = DropSchemaResponse;
7682
7683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7684 formatter.write_str("struct ddl_service.DropSchemaResponse")
7685 }
7686
7687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSchemaResponse, V::Error>
7688 where
7689 V: serde::de::MapAccess<'de>,
7690 {
7691 let mut status__ = None;
7692 let mut version__ = None;
7693 while let Some(k) = map_.next_key()? {
7694 match k {
7695 GeneratedField::Status => {
7696 if status__.is_some() {
7697 return Err(serde::de::Error::duplicate_field("status"));
7698 }
7699 status__ = map_.next_value()?;
7700 }
7701 GeneratedField::Version => {
7702 if version__.is_some() {
7703 return Err(serde::de::Error::duplicate_field("version"));
7704 }
7705 version__ = map_.next_value()?;
7706 }
7707 }
7708 }
7709 Ok(DropSchemaResponse {
7710 status: status__,
7711 version: version__,
7712 })
7713 }
7714 }
7715 deserializer.deserialize_struct("ddl_service.DropSchemaResponse", FIELDS, GeneratedVisitor)
7716 }
7717}
7718impl serde::Serialize for DropSecretRequest {
7719 #[allow(deprecated)]
7720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7721 where
7722 S: serde::Serializer,
7723 {
7724 use serde::ser::SerializeStruct;
7725 let mut len = 0;
7726 if self.secret_id != 0 {
7727 len += 1;
7728 }
7729 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretRequest", len)?;
7730 if self.secret_id != 0 {
7731 struct_ser.serialize_field("secretId", &self.secret_id)?;
7732 }
7733 struct_ser.end()
7734 }
7735}
7736impl<'de> serde::Deserialize<'de> for DropSecretRequest {
7737 #[allow(deprecated)]
7738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7739 where
7740 D: serde::Deserializer<'de>,
7741 {
7742 const FIELDS: &[&str] = &[
7743 "secret_id",
7744 "secretId",
7745 ];
7746
7747 #[allow(clippy::enum_variant_names)]
7748 enum GeneratedField {
7749 SecretId,
7750 }
7751 impl<'de> serde::Deserialize<'de> for GeneratedField {
7752 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7753 where
7754 D: serde::Deserializer<'de>,
7755 {
7756 struct GeneratedVisitor;
7757
7758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7759 type Value = GeneratedField;
7760
7761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7762 write!(formatter, "expected one of: {:?}", &FIELDS)
7763 }
7764
7765 #[allow(unused_variables)]
7766 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7767 where
7768 E: serde::de::Error,
7769 {
7770 match value {
7771 "secretId" | "secret_id" => Ok(GeneratedField::SecretId),
7772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7773 }
7774 }
7775 }
7776 deserializer.deserialize_identifier(GeneratedVisitor)
7777 }
7778 }
7779 struct GeneratedVisitor;
7780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7781 type Value = DropSecretRequest;
7782
7783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7784 formatter.write_str("struct ddl_service.DropSecretRequest")
7785 }
7786
7787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretRequest, V::Error>
7788 where
7789 V: serde::de::MapAccess<'de>,
7790 {
7791 let mut secret_id__ = None;
7792 while let Some(k) = map_.next_key()? {
7793 match k {
7794 GeneratedField::SecretId => {
7795 if secret_id__.is_some() {
7796 return Err(serde::de::Error::duplicate_field("secretId"));
7797 }
7798 secret_id__ =
7799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7800 ;
7801 }
7802 }
7803 }
7804 Ok(DropSecretRequest {
7805 secret_id: secret_id__.unwrap_or_default(),
7806 })
7807 }
7808 }
7809 deserializer.deserialize_struct("ddl_service.DropSecretRequest", FIELDS, GeneratedVisitor)
7810 }
7811}
7812impl serde::Serialize for DropSecretResponse {
7813 #[allow(deprecated)]
7814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7815 where
7816 S: serde::Serializer,
7817 {
7818 use serde::ser::SerializeStruct;
7819 let mut len = 0;
7820 if self.version.is_some() {
7821 len += 1;
7822 }
7823 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSecretResponse", len)?;
7824 if let Some(v) = self.version.as_ref() {
7825 struct_ser.serialize_field("version", v)?;
7826 }
7827 struct_ser.end()
7828 }
7829}
7830impl<'de> serde::Deserialize<'de> for DropSecretResponse {
7831 #[allow(deprecated)]
7832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7833 where
7834 D: serde::Deserializer<'de>,
7835 {
7836 const FIELDS: &[&str] = &[
7837 "version",
7838 ];
7839
7840 #[allow(clippy::enum_variant_names)]
7841 enum GeneratedField {
7842 Version,
7843 }
7844 impl<'de> serde::Deserialize<'de> for GeneratedField {
7845 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7846 where
7847 D: serde::Deserializer<'de>,
7848 {
7849 struct GeneratedVisitor;
7850
7851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7852 type Value = GeneratedField;
7853
7854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7855 write!(formatter, "expected one of: {:?}", &FIELDS)
7856 }
7857
7858 #[allow(unused_variables)]
7859 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7860 where
7861 E: serde::de::Error,
7862 {
7863 match value {
7864 "version" => Ok(GeneratedField::Version),
7865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7866 }
7867 }
7868 }
7869 deserializer.deserialize_identifier(GeneratedVisitor)
7870 }
7871 }
7872 struct GeneratedVisitor;
7873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7874 type Value = DropSecretResponse;
7875
7876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7877 formatter.write_str("struct ddl_service.DropSecretResponse")
7878 }
7879
7880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSecretResponse, V::Error>
7881 where
7882 V: serde::de::MapAccess<'de>,
7883 {
7884 let mut version__ = None;
7885 while let Some(k) = map_.next_key()? {
7886 match k {
7887 GeneratedField::Version => {
7888 if version__.is_some() {
7889 return Err(serde::de::Error::duplicate_field("version"));
7890 }
7891 version__ = map_.next_value()?;
7892 }
7893 }
7894 }
7895 Ok(DropSecretResponse {
7896 version: version__,
7897 })
7898 }
7899 }
7900 deserializer.deserialize_struct("ddl_service.DropSecretResponse", FIELDS, GeneratedVisitor)
7901 }
7902}
7903impl serde::Serialize for DropSinkRequest {
7904 #[allow(deprecated)]
7905 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7906 where
7907 S: serde::Serializer,
7908 {
7909 use serde::ser::SerializeStruct;
7910 let mut len = 0;
7911 if self.sink_id != 0 {
7912 len += 1;
7913 }
7914 if self.cascade {
7915 len += 1;
7916 }
7917 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkRequest", len)?;
7918 if self.sink_id != 0 {
7919 struct_ser.serialize_field("sinkId", &self.sink_id)?;
7920 }
7921 if self.cascade {
7922 struct_ser.serialize_field("cascade", &self.cascade)?;
7923 }
7924 struct_ser.end()
7925 }
7926}
7927impl<'de> serde::Deserialize<'de> for DropSinkRequest {
7928 #[allow(deprecated)]
7929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7930 where
7931 D: serde::Deserializer<'de>,
7932 {
7933 const FIELDS: &[&str] = &[
7934 "sink_id",
7935 "sinkId",
7936 "cascade",
7937 ];
7938
7939 #[allow(clippy::enum_variant_names)]
7940 enum GeneratedField {
7941 SinkId,
7942 Cascade,
7943 }
7944 impl<'de> serde::Deserialize<'de> for GeneratedField {
7945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7946 where
7947 D: serde::Deserializer<'de>,
7948 {
7949 struct GeneratedVisitor;
7950
7951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7952 type Value = GeneratedField;
7953
7954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7955 write!(formatter, "expected one of: {:?}", &FIELDS)
7956 }
7957
7958 #[allow(unused_variables)]
7959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7960 where
7961 E: serde::de::Error,
7962 {
7963 match value {
7964 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
7965 "cascade" => Ok(GeneratedField::Cascade),
7966 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7967 }
7968 }
7969 }
7970 deserializer.deserialize_identifier(GeneratedVisitor)
7971 }
7972 }
7973 struct GeneratedVisitor;
7974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7975 type Value = DropSinkRequest;
7976
7977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7978 formatter.write_str("struct ddl_service.DropSinkRequest")
7979 }
7980
7981 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkRequest, V::Error>
7982 where
7983 V: serde::de::MapAccess<'de>,
7984 {
7985 let mut sink_id__ = None;
7986 let mut cascade__ = None;
7987 while let Some(k) = map_.next_key()? {
7988 match k {
7989 GeneratedField::SinkId => {
7990 if sink_id__.is_some() {
7991 return Err(serde::de::Error::duplicate_field("sinkId"));
7992 }
7993 sink_id__ =
7994 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7995 ;
7996 }
7997 GeneratedField::Cascade => {
7998 if cascade__.is_some() {
7999 return Err(serde::de::Error::duplicate_field("cascade"));
8000 }
8001 cascade__ = Some(map_.next_value()?);
8002 }
8003 }
8004 }
8005 Ok(DropSinkRequest {
8006 sink_id: sink_id__.unwrap_or_default(),
8007 cascade: cascade__.unwrap_or_default(),
8008 })
8009 }
8010 }
8011 deserializer.deserialize_struct("ddl_service.DropSinkRequest", FIELDS, GeneratedVisitor)
8012 }
8013}
8014impl serde::Serialize for DropSinkResponse {
8015 #[allow(deprecated)]
8016 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8017 where
8018 S: serde::Serializer,
8019 {
8020 use serde::ser::SerializeStruct;
8021 let mut len = 0;
8022 if self.status.is_some() {
8023 len += 1;
8024 }
8025 if self.version.is_some() {
8026 len += 1;
8027 }
8028 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSinkResponse", len)?;
8029 if let Some(v) = self.status.as_ref() {
8030 struct_ser.serialize_field("status", v)?;
8031 }
8032 if let Some(v) = self.version.as_ref() {
8033 struct_ser.serialize_field("version", v)?;
8034 }
8035 struct_ser.end()
8036 }
8037}
8038impl<'de> serde::Deserialize<'de> for DropSinkResponse {
8039 #[allow(deprecated)]
8040 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8041 where
8042 D: serde::Deserializer<'de>,
8043 {
8044 const FIELDS: &[&str] = &[
8045 "status",
8046 "version",
8047 ];
8048
8049 #[allow(clippy::enum_variant_names)]
8050 enum GeneratedField {
8051 Status,
8052 Version,
8053 }
8054 impl<'de> serde::Deserialize<'de> for GeneratedField {
8055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8056 where
8057 D: serde::Deserializer<'de>,
8058 {
8059 struct GeneratedVisitor;
8060
8061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8062 type Value = GeneratedField;
8063
8064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8065 write!(formatter, "expected one of: {:?}", &FIELDS)
8066 }
8067
8068 #[allow(unused_variables)]
8069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8070 where
8071 E: serde::de::Error,
8072 {
8073 match value {
8074 "status" => Ok(GeneratedField::Status),
8075 "version" => Ok(GeneratedField::Version),
8076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8077 }
8078 }
8079 }
8080 deserializer.deserialize_identifier(GeneratedVisitor)
8081 }
8082 }
8083 struct GeneratedVisitor;
8084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8085 type Value = DropSinkResponse;
8086
8087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8088 formatter.write_str("struct ddl_service.DropSinkResponse")
8089 }
8090
8091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSinkResponse, V::Error>
8092 where
8093 V: serde::de::MapAccess<'de>,
8094 {
8095 let mut status__ = None;
8096 let mut version__ = None;
8097 while let Some(k) = map_.next_key()? {
8098 match k {
8099 GeneratedField::Status => {
8100 if status__.is_some() {
8101 return Err(serde::de::Error::duplicate_field("status"));
8102 }
8103 status__ = map_.next_value()?;
8104 }
8105 GeneratedField::Version => {
8106 if version__.is_some() {
8107 return Err(serde::de::Error::duplicate_field("version"));
8108 }
8109 version__ = map_.next_value()?;
8110 }
8111 }
8112 }
8113 Ok(DropSinkResponse {
8114 status: status__,
8115 version: version__,
8116 })
8117 }
8118 }
8119 deserializer.deserialize_struct("ddl_service.DropSinkResponse", FIELDS, GeneratedVisitor)
8120 }
8121}
8122impl serde::Serialize for DropSourceRequest {
8123 #[allow(deprecated)]
8124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8125 where
8126 S: serde::Serializer,
8127 {
8128 use serde::ser::SerializeStruct;
8129 let mut len = 0;
8130 if self.source_id != 0 {
8131 len += 1;
8132 }
8133 if self.cascade {
8134 len += 1;
8135 }
8136 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceRequest", len)?;
8137 if self.source_id != 0 {
8138 struct_ser.serialize_field("sourceId", &self.source_id)?;
8139 }
8140 if self.cascade {
8141 struct_ser.serialize_field("cascade", &self.cascade)?;
8142 }
8143 struct_ser.end()
8144 }
8145}
8146impl<'de> serde::Deserialize<'de> for DropSourceRequest {
8147 #[allow(deprecated)]
8148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8149 where
8150 D: serde::Deserializer<'de>,
8151 {
8152 const FIELDS: &[&str] = &[
8153 "source_id",
8154 "sourceId",
8155 "cascade",
8156 ];
8157
8158 #[allow(clippy::enum_variant_names)]
8159 enum GeneratedField {
8160 SourceId,
8161 Cascade,
8162 }
8163 impl<'de> serde::Deserialize<'de> for GeneratedField {
8164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8165 where
8166 D: serde::Deserializer<'de>,
8167 {
8168 struct GeneratedVisitor;
8169
8170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8171 type Value = GeneratedField;
8172
8173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8174 write!(formatter, "expected one of: {:?}", &FIELDS)
8175 }
8176
8177 #[allow(unused_variables)]
8178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8179 where
8180 E: serde::de::Error,
8181 {
8182 match value {
8183 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8184 "cascade" => Ok(GeneratedField::Cascade),
8185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8186 }
8187 }
8188 }
8189 deserializer.deserialize_identifier(GeneratedVisitor)
8190 }
8191 }
8192 struct GeneratedVisitor;
8193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8194 type Value = DropSourceRequest;
8195
8196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8197 formatter.write_str("struct ddl_service.DropSourceRequest")
8198 }
8199
8200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceRequest, V::Error>
8201 where
8202 V: serde::de::MapAccess<'de>,
8203 {
8204 let mut source_id__ = None;
8205 let mut cascade__ = None;
8206 while let Some(k) = map_.next_key()? {
8207 match k {
8208 GeneratedField::SourceId => {
8209 if source_id__.is_some() {
8210 return Err(serde::de::Error::duplicate_field("sourceId"));
8211 }
8212 source_id__ =
8213 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8214 ;
8215 }
8216 GeneratedField::Cascade => {
8217 if cascade__.is_some() {
8218 return Err(serde::de::Error::duplicate_field("cascade"));
8219 }
8220 cascade__ = Some(map_.next_value()?);
8221 }
8222 }
8223 }
8224 Ok(DropSourceRequest {
8225 source_id: source_id__.unwrap_or_default(),
8226 cascade: cascade__.unwrap_or_default(),
8227 })
8228 }
8229 }
8230 deserializer.deserialize_struct("ddl_service.DropSourceRequest", FIELDS, GeneratedVisitor)
8231 }
8232}
8233impl serde::Serialize for DropSourceResponse {
8234 #[allow(deprecated)]
8235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8236 where
8237 S: serde::Serializer,
8238 {
8239 use serde::ser::SerializeStruct;
8240 let mut len = 0;
8241 if self.status.is_some() {
8242 len += 1;
8243 }
8244 if self.version.is_some() {
8245 len += 1;
8246 }
8247 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSourceResponse", len)?;
8248 if let Some(v) = self.status.as_ref() {
8249 struct_ser.serialize_field("status", v)?;
8250 }
8251 if let Some(v) = self.version.as_ref() {
8252 struct_ser.serialize_field("version", v)?;
8253 }
8254 struct_ser.end()
8255 }
8256}
8257impl<'de> serde::Deserialize<'de> for DropSourceResponse {
8258 #[allow(deprecated)]
8259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8260 where
8261 D: serde::Deserializer<'de>,
8262 {
8263 const FIELDS: &[&str] = &[
8264 "status",
8265 "version",
8266 ];
8267
8268 #[allow(clippy::enum_variant_names)]
8269 enum GeneratedField {
8270 Status,
8271 Version,
8272 }
8273 impl<'de> serde::Deserialize<'de> for GeneratedField {
8274 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8275 where
8276 D: serde::Deserializer<'de>,
8277 {
8278 struct GeneratedVisitor;
8279
8280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8281 type Value = GeneratedField;
8282
8283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8284 write!(formatter, "expected one of: {:?}", &FIELDS)
8285 }
8286
8287 #[allow(unused_variables)]
8288 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8289 where
8290 E: serde::de::Error,
8291 {
8292 match value {
8293 "status" => Ok(GeneratedField::Status),
8294 "version" => Ok(GeneratedField::Version),
8295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8296 }
8297 }
8298 }
8299 deserializer.deserialize_identifier(GeneratedVisitor)
8300 }
8301 }
8302 struct GeneratedVisitor;
8303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8304 type Value = DropSourceResponse;
8305
8306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8307 formatter.write_str("struct ddl_service.DropSourceResponse")
8308 }
8309
8310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSourceResponse, V::Error>
8311 where
8312 V: serde::de::MapAccess<'de>,
8313 {
8314 let mut status__ = None;
8315 let mut version__ = None;
8316 while let Some(k) = map_.next_key()? {
8317 match k {
8318 GeneratedField::Status => {
8319 if status__.is_some() {
8320 return Err(serde::de::Error::duplicate_field("status"));
8321 }
8322 status__ = map_.next_value()?;
8323 }
8324 GeneratedField::Version => {
8325 if version__.is_some() {
8326 return Err(serde::de::Error::duplicate_field("version"));
8327 }
8328 version__ = map_.next_value()?;
8329 }
8330 }
8331 }
8332 Ok(DropSourceResponse {
8333 status: status__,
8334 version: version__,
8335 })
8336 }
8337 }
8338 deserializer.deserialize_struct("ddl_service.DropSourceResponse", FIELDS, GeneratedVisitor)
8339 }
8340}
8341impl serde::Serialize for DropSubscriptionRequest {
8342 #[allow(deprecated)]
8343 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8344 where
8345 S: serde::Serializer,
8346 {
8347 use serde::ser::SerializeStruct;
8348 let mut len = 0;
8349 if self.subscription_id != 0 {
8350 len += 1;
8351 }
8352 if self.cascade {
8353 len += 1;
8354 }
8355 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionRequest", len)?;
8356 if self.subscription_id != 0 {
8357 struct_ser.serialize_field("subscriptionId", &self.subscription_id)?;
8358 }
8359 if self.cascade {
8360 struct_ser.serialize_field("cascade", &self.cascade)?;
8361 }
8362 struct_ser.end()
8363 }
8364}
8365impl<'de> serde::Deserialize<'de> for DropSubscriptionRequest {
8366 #[allow(deprecated)]
8367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8368 where
8369 D: serde::Deserializer<'de>,
8370 {
8371 const FIELDS: &[&str] = &[
8372 "subscription_id",
8373 "subscriptionId",
8374 "cascade",
8375 ];
8376
8377 #[allow(clippy::enum_variant_names)]
8378 enum GeneratedField {
8379 SubscriptionId,
8380 Cascade,
8381 }
8382 impl<'de> serde::Deserialize<'de> for GeneratedField {
8383 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8384 where
8385 D: serde::Deserializer<'de>,
8386 {
8387 struct GeneratedVisitor;
8388
8389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8390 type Value = GeneratedField;
8391
8392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8393 write!(formatter, "expected one of: {:?}", &FIELDS)
8394 }
8395
8396 #[allow(unused_variables)]
8397 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8398 where
8399 E: serde::de::Error,
8400 {
8401 match value {
8402 "subscriptionId" | "subscription_id" => Ok(GeneratedField::SubscriptionId),
8403 "cascade" => Ok(GeneratedField::Cascade),
8404 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8405 }
8406 }
8407 }
8408 deserializer.deserialize_identifier(GeneratedVisitor)
8409 }
8410 }
8411 struct GeneratedVisitor;
8412 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8413 type Value = DropSubscriptionRequest;
8414
8415 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8416 formatter.write_str("struct ddl_service.DropSubscriptionRequest")
8417 }
8418
8419 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionRequest, V::Error>
8420 where
8421 V: serde::de::MapAccess<'de>,
8422 {
8423 let mut subscription_id__ = None;
8424 let mut cascade__ = None;
8425 while let Some(k) = map_.next_key()? {
8426 match k {
8427 GeneratedField::SubscriptionId => {
8428 if subscription_id__.is_some() {
8429 return Err(serde::de::Error::duplicate_field("subscriptionId"));
8430 }
8431 subscription_id__ =
8432 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8433 ;
8434 }
8435 GeneratedField::Cascade => {
8436 if cascade__.is_some() {
8437 return Err(serde::de::Error::duplicate_field("cascade"));
8438 }
8439 cascade__ = Some(map_.next_value()?);
8440 }
8441 }
8442 }
8443 Ok(DropSubscriptionRequest {
8444 subscription_id: subscription_id__.unwrap_or_default(),
8445 cascade: cascade__.unwrap_or_default(),
8446 })
8447 }
8448 }
8449 deserializer.deserialize_struct("ddl_service.DropSubscriptionRequest", FIELDS, GeneratedVisitor)
8450 }
8451}
8452impl serde::Serialize for DropSubscriptionResponse {
8453 #[allow(deprecated)]
8454 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8455 where
8456 S: serde::Serializer,
8457 {
8458 use serde::ser::SerializeStruct;
8459 let mut len = 0;
8460 if self.status.is_some() {
8461 len += 1;
8462 }
8463 if self.version.is_some() {
8464 len += 1;
8465 }
8466 let mut struct_ser = serializer.serialize_struct("ddl_service.DropSubscriptionResponse", len)?;
8467 if let Some(v) = self.status.as_ref() {
8468 struct_ser.serialize_field("status", v)?;
8469 }
8470 if let Some(v) = self.version.as_ref() {
8471 struct_ser.serialize_field("version", v)?;
8472 }
8473 struct_ser.end()
8474 }
8475}
8476impl<'de> serde::Deserialize<'de> for DropSubscriptionResponse {
8477 #[allow(deprecated)]
8478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8479 where
8480 D: serde::Deserializer<'de>,
8481 {
8482 const FIELDS: &[&str] = &[
8483 "status",
8484 "version",
8485 ];
8486
8487 #[allow(clippy::enum_variant_names)]
8488 enum GeneratedField {
8489 Status,
8490 Version,
8491 }
8492 impl<'de> serde::Deserialize<'de> for GeneratedField {
8493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8494 where
8495 D: serde::Deserializer<'de>,
8496 {
8497 struct GeneratedVisitor;
8498
8499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8500 type Value = GeneratedField;
8501
8502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8503 write!(formatter, "expected one of: {:?}", &FIELDS)
8504 }
8505
8506 #[allow(unused_variables)]
8507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8508 where
8509 E: serde::de::Error,
8510 {
8511 match value {
8512 "status" => Ok(GeneratedField::Status),
8513 "version" => Ok(GeneratedField::Version),
8514 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8515 }
8516 }
8517 }
8518 deserializer.deserialize_identifier(GeneratedVisitor)
8519 }
8520 }
8521 struct GeneratedVisitor;
8522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8523 type Value = DropSubscriptionResponse;
8524
8525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8526 formatter.write_str("struct ddl_service.DropSubscriptionResponse")
8527 }
8528
8529 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionResponse, V::Error>
8530 where
8531 V: serde::de::MapAccess<'de>,
8532 {
8533 let mut status__ = None;
8534 let mut version__ = None;
8535 while let Some(k) = map_.next_key()? {
8536 match k {
8537 GeneratedField::Status => {
8538 if status__.is_some() {
8539 return Err(serde::de::Error::duplicate_field("status"));
8540 }
8541 status__ = map_.next_value()?;
8542 }
8543 GeneratedField::Version => {
8544 if version__.is_some() {
8545 return Err(serde::de::Error::duplicate_field("version"));
8546 }
8547 version__ = map_.next_value()?;
8548 }
8549 }
8550 }
8551 Ok(DropSubscriptionResponse {
8552 status: status__,
8553 version: version__,
8554 })
8555 }
8556 }
8557 deserializer.deserialize_struct("ddl_service.DropSubscriptionResponse", FIELDS, GeneratedVisitor)
8558 }
8559}
8560impl serde::Serialize for DropTableRequest {
8561 #[allow(deprecated)]
8562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8563 where
8564 S: serde::Serializer,
8565 {
8566 use serde::ser::SerializeStruct;
8567 let mut len = 0;
8568 if self.table_id != 0 {
8569 len += 1;
8570 }
8571 if self.cascade {
8572 len += 1;
8573 }
8574 if self.source_id.is_some() {
8575 len += 1;
8576 }
8577 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableRequest", len)?;
8578 if self.table_id != 0 {
8579 struct_ser.serialize_field("tableId", &self.table_id)?;
8580 }
8581 if self.cascade {
8582 struct_ser.serialize_field("cascade", &self.cascade)?;
8583 }
8584 if let Some(v) = self.source_id.as_ref() {
8585 match v {
8586 drop_table_request::SourceId::Id(v) => {
8587 struct_ser.serialize_field("id", v)?;
8588 }
8589 }
8590 }
8591 struct_ser.end()
8592 }
8593}
8594impl<'de> serde::Deserialize<'de> for DropTableRequest {
8595 #[allow(deprecated)]
8596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8597 where
8598 D: serde::Deserializer<'de>,
8599 {
8600 const FIELDS: &[&str] = &[
8601 "table_id",
8602 "tableId",
8603 "cascade",
8604 "id",
8605 ];
8606
8607 #[allow(clippy::enum_variant_names)]
8608 enum GeneratedField {
8609 TableId,
8610 Cascade,
8611 Id,
8612 }
8613 impl<'de> serde::Deserialize<'de> for GeneratedField {
8614 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8615 where
8616 D: serde::Deserializer<'de>,
8617 {
8618 struct GeneratedVisitor;
8619
8620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8621 type Value = GeneratedField;
8622
8623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8624 write!(formatter, "expected one of: {:?}", &FIELDS)
8625 }
8626
8627 #[allow(unused_variables)]
8628 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8629 where
8630 E: serde::de::Error,
8631 {
8632 match value {
8633 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8634 "cascade" => Ok(GeneratedField::Cascade),
8635 "id" => Ok(GeneratedField::Id),
8636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8637 }
8638 }
8639 }
8640 deserializer.deserialize_identifier(GeneratedVisitor)
8641 }
8642 }
8643 struct GeneratedVisitor;
8644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8645 type Value = DropTableRequest;
8646
8647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8648 formatter.write_str("struct ddl_service.DropTableRequest")
8649 }
8650
8651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableRequest, V::Error>
8652 where
8653 V: serde::de::MapAccess<'de>,
8654 {
8655 let mut table_id__ = None;
8656 let mut cascade__ = None;
8657 let mut source_id__ = None;
8658 while let Some(k) = map_.next_key()? {
8659 match k {
8660 GeneratedField::TableId => {
8661 if table_id__.is_some() {
8662 return Err(serde::de::Error::duplicate_field("tableId"));
8663 }
8664 table_id__ =
8665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8666 ;
8667 }
8668 GeneratedField::Cascade => {
8669 if cascade__.is_some() {
8670 return Err(serde::de::Error::duplicate_field("cascade"));
8671 }
8672 cascade__ = Some(map_.next_value()?);
8673 }
8674 GeneratedField::Id => {
8675 if source_id__.is_some() {
8676 return Err(serde::de::Error::duplicate_field("id"));
8677 }
8678 source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| drop_table_request::SourceId::Id(x.0));
8679 }
8680 }
8681 }
8682 Ok(DropTableRequest {
8683 table_id: table_id__.unwrap_or_default(),
8684 cascade: cascade__.unwrap_or_default(),
8685 source_id: source_id__,
8686 })
8687 }
8688 }
8689 deserializer.deserialize_struct("ddl_service.DropTableRequest", FIELDS, GeneratedVisitor)
8690 }
8691}
8692impl serde::Serialize for DropTableResponse {
8693 #[allow(deprecated)]
8694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8695 where
8696 S: serde::Serializer,
8697 {
8698 use serde::ser::SerializeStruct;
8699 let mut len = 0;
8700 if self.status.is_some() {
8701 len += 1;
8702 }
8703 if self.version.is_some() {
8704 len += 1;
8705 }
8706 let mut struct_ser = serializer.serialize_struct("ddl_service.DropTableResponse", len)?;
8707 if let Some(v) = self.status.as_ref() {
8708 struct_ser.serialize_field("status", v)?;
8709 }
8710 if let Some(v) = self.version.as_ref() {
8711 struct_ser.serialize_field("version", v)?;
8712 }
8713 struct_ser.end()
8714 }
8715}
8716impl<'de> serde::Deserialize<'de> for DropTableResponse {
8717 #[allow(deprecated)]
8718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8719 where
8720 D: serde::Deserializer<'de>,
8721 {
8722 const FIELDS: &[&str] = &[
8723 "status",
8724 "version",
8725 ];
8726
8727 #[allow(clippy::enum_variant_names)]
8728 enum GeneratedField {
8729 Status,
8730 Version,
8731 }
8732 impl<'de> serde::Deserialize<'de> for GeneratedField {
8733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8734 where
8735 D: serde::Deserializer<'de>,
8736 {
8737 struct GeneratedVisitor;
8738
8739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8740 type Value = GeneratedField;
8741
8742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8743 write!(formatter, "expected one of: {:?}", &FIELDS)
8744 }
8745
8746 #[allow(unused_variables)]
8747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8748 where
8749 E: serde::de::Error,
8750 {
8751 match value {
8752 "status" => Ok(GeneratedField::Status),
8753 "version" => Ok(GeneratedField::Version),
8754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8755 }
8756 }
8757 }
8758 deserializer.deserialize_identifier(GeneratedVisitor)
8759 }
8760 }
8761 struct GeneratedVisitor;
8762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8763 type Value = DropTableResponse;
8764
8765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8766 formatter.write_str("struct ddl_service.DropTableResponse")
8767 }
8768
8769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropTableResponse, V::Error>
8770 where
8771 V: serde::de::MapAccess<'de>,
8772 {
8773 let mut status__ = None;
8774 let mut version__ = None;
8775 while let Some(k) = map_.next_key()? {
8776 match k {
8777 GeneratedField::Status => {
8778 if status__.is_some() {
8779 return Err(serde::de::Error::duplicate_field("status"));
8780 }
8781 status__ = map_.next_value()?;
8782 }
8783 GeneratedField::Version => {
8784 if version__.is_some() {
8785 return Err(serde::de::Error::duplicate_field("version"));
8786 }
8787 version__ = map_.next_value()?;
8788 }
8789 }
8790 }
8791 Ok(DropTableResponse {
8792 status: status__,
8793 version: version__,
8794 })
8795 }
8796 }
8797 deserializer.deserialize_struct("ddl_service.DropTableResponse", FIELDS, GeneratedVisitor)
8798 }
8799}
8800impl serde::Serialize for DropViewRequest {
8801 #[allow(deprecated)]
8802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8803 where
8804 S: serde::Serializer,
8805 {
8806 use serde::ser::SerializeStruct;
8807 let mut len = 0;
8808 if self.view_id != 0 {
8809 len += 1;
8810 }
8811 if self.cascade {
8812 len += 1;
8813 }
8814 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewRequest", len)?;
8815 if self.view_id != 0 {
8816 struct_ser.serialize_field("viewId", &self.view_id)?;
8817 }
8818 if self.cascade {
8819 struct_ser.serialize_field("cascade", &self.cascade)?;
8820 }
8821 struct_ser.end()
8822 }
8823}
8824impl<'de> serde::Deserialize<'de> for DropViewRequest {
8825 #[allow(deprecated)]
8826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8827 where
8828 D: serde::Deserializer<'de>,
8829 {
8830 const FIELDS: &[&str] = &[
8831 "view_id",
8832 "viewId",
8833 "cascade",
8834 ];
8835
8836 #[allow(clippy::enum_variant_names)]
8837 enum GeneratedField {
8838 ViewId,
8839 Cascade,
8840 }
8841 impl<'de> serde::Deserialize<'de> for GeneratedField {
8842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8843 where
8844 D: serde::Deserializer<'de>,
8845 {
8846 struct GeneratedVisitor;
8847
8848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8849 type Value = GeneratedField;
8850
8851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8852 write!(formatter, "expected one of: {:?}", &FIELDS)
8853 }
8854
8855 #[allow(unused_variables)]
8856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8857 where
8858 E: serde::de::Error,
8859 {
8860 match value {
8861 "viewId" | "view_id" => Ok(GeneratedField::ViewId),
8862 "cascade" => Ok(GeneratedField::Cascade),
8863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8864 }
8865 }
8866 }
8867 deserializer.deserialize_identifier(GeneratedVisitor)
8868 }
8869 }
8870 struct GeneratedVisitor;
8871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8872 type Value = DropViewRequest;
8873
8874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8875 formatter.write_str("struct ddl_service.DropViewRequest")
8876 }
8877
8878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewRequest, V::Error>
8879 where
8880 V: serde::de::MapAccess<'de>,
8881 {
8882 let mut view_id__ = None;
8883 let mut cascade__ = None;
8884 while let Some(k) = map_.next_key()? {
8885 match k {
8886 GeneratedField::ViewId => {
8887 if view_id__.is_some() {
8888 return Err(serde::de::Error::duplicate_field("viewId"));
8889 }
8890 view_id__ =
8891 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8892 ;
8893 }
8894 GeneratedField::Cascade => {
8895 if cascade__.is_some() {
8896 return Err(serde::de::Error::duplicate_field("cascade"));
8897 }
8898 cascade__ = Some(map_.next_value()?);
8899 }
8900 }
8901 }
8902 Ok(DropViewRequest {
8903 view_id: view_id__.unwrap_or_default(),
8904 cascade: cascade__.unwrap_or_default(),
8905 })
8906 }
8907 }
8908 deserializer.deserialize_struct("ddl_service.DropViewRequest", FIELDS, GeneratedVisitor)
8909 }
8910}
8911impl serde::Serialize for DropViewResponse {
8912 #[allow(deprecated)]
8913 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8914 where
8915 S: serde::Serializer,
8916 {
8917 use serde::ser::SerializeStruct;
8918 let mut len = 0;
8919 if self.status.is_some() {
8920 len += 1;
8921 }
8922 if self.version.is_some() {
8923 len += 1;
8924 }
8925 let mut struct_ser = serializer.serialize_struct("ddl_service.DropViewResponse", len)?;
8926 if let Some(v) = self.status.as_ref() {
8927 struct_ser.serialize_field("status", v)?;
8928 }
8929 if let Some(v) = self.version.as_ref() {
8930 struct_ser.serialize_field("version", v)?;
8931 }
8932 struct_ser.end()
8933 }
8934}
8935impl<'de> serde::Deserialize<'de> for DropViewResponse {
8936 #[allow(deprecated)]
8937 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8938 where
8939 D: serde::Deserializer<'de>,
8940 {
8941 const FIELDS: &[&str] = &[
8942 "status",
8943 "version",
8944 ];
8945
8946 #[allow(clippy::enum_variant_names)]
8947 enum GeneratedField {
8948 Status,
8949 Version,
8950 }
8951 impl<'de> serde::Deserialize<'de> for GeneratedField {
8952 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8953 where
8954 D: serde::Deserializer<'de>,
8955 {
8956 struct GeneratedVisitor;
8957
8958 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8959 type Value = GeneratedField;
8960
8961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8962 write!(formatter, "expected one of: {:?}", &FIELDS)
8963 }
8964
8965 #[allow(unused_variables)]
8966 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8967 where
8968 E: serde::de::Error,
8969 {
8970 match value {
8971 "status" => Ok(GeneratedField::Status),
8972 "version" => Ok(GeneratedField::Version),
8973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8974 }
8975 }
8976 }
8977 deserializer.deserialize_identifier(GeneratedVisitor)
8978 }
8979 }
8980 struct GeneratedVisitor;
8981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8982 type Value = DropViewResponse;
8983
8984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8985 formatter.write_str("struct ddl_service.DropViewResponse")
8986 }
8987
8988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropViewResponse, V::Error>
8989 where
8990 V: serde::de::MapAccess<'de>,
8991 {
8992 let mut status__ = None;
8993 let mut version__ = None;
8994 while let Some(k) = map_.next_key()? {
8995 match k {
8996 GeneratedField::Status => {
8997 if status__.is_some() {
8998 return Err(serde::de::Error::duplicate_field("status"));
8999 }
9000 status__ = map_.next_value()?;
9001 }
9002 GeneratedField::Version => {
9003 if version__.is_some() {
9004 return Err(serde::de::Error::duplicate_field("version"));
9005 }
9006 version__ = map_.next_value()?;
9007 }
9008 }
9009 }
9010 Ok(DropViewResponse {
9011 status: status__,
9012 version: version__,
9013 })
9014 }
9015 }
9016 deserializer.deserialize_struct("ddl_service.DropViewResponse", FIELDS, GeneratedVisitor)
9017 }
9018}
9019impl serde::Serialize for ExpireIcebergTableSnapshotsRequest {
9020 #[allow(deprecated)]
9021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9022 where
9023 S: serde::Serializer,
9024 {
9025 use serde::ser::SerializeStruct;
9026 let mut len = 0;
9027 if self.sink_id != 0 {
9028 len += 1;
9029 }
9030 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", len)?;
9031 if self.sink_id != 0 {
9032 struct_ser.serialize_field("sinkId", &self.sink_id)?;
9033 }
9034 struct_ser.end()
9035 }
9036}
9037impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsRequest {
9038 #[allow(deprecated)]
9039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9040 where
9041 D: serde::Deserializer<'de>,
9042 {
9043 const FIELDS: &[&str] = &[
9044 "sink_id",
9045 "sinkId",
9046 ];
9047
9048 #[allow(clippy::enum_variant_names)]
9049 enum GeneratedField {
9050 SinkId,
9051 }
9052 impl<'de> serde::Deserialize<'de> for GeneratedField {
9053 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9054 where
9055 D: serde::Deserializer<'de>,
9056 {
9057 struct GeneratedVisitor;
9058
9059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9060 type Value = GeneratedField;
9061
9062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9063 write!(formatter, "expected one of: {:?}", &FIELDS)
9064 }
9065
9066 #[allow(unused_variables)]
9067 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9068 where
9069 E: serde::de::Error,
9070 {
9071 match value {
9072 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
9073 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9074 }
9075 }
9076 }
9077 deserializer.deserialize_identifier(GeneratedVisitor)
9078 }
9079 }
9080 struct GeneratedVisitor;
9081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9082 type Value = ExpireIcebergTableSnapshotsRequest;
9083
9084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9085 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsRequest")
9086 }
9087
9088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsRequest, V::Error>
9089 where
9090 V: serde::de::MapAccess<'de>,
9091 {
9092 let mut sink_id__ = None;
9093 while let Some(k) = map_.next_key()? {
9094 match k {
9095 GeneratedField::SinkId => {
9096 if sink_id__.is_some() {
9097 return Err(serde::de::Error::duplicate_field("sinkId"));
9098 }
9099 sink_id__ =
9100 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9101 ;
9102 }
9103 }
9104 }
9105 Ok(ExpireIcebergTableSnapshotsRequest {
9106 sink_id: sink_id__.unwrap_or_default(),
9107 })
9108 }
9109 }
9110 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsRequest", FIELDS, GeneratedVisitor)
9111 }
9112}
9113impl serde::Serialize for ExpireIcebergTableSnapshotsResponse {
9114 #[allow(deprecated)]
9115 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9116 where
9117 S: serde::Serializer,
9118 {
9119 use serde::ser::SerializeStruct;
9120 let mut len = 0;
9121 if self.status.is_some() {
9122 len += 1;
9123 }
9124 let mut struct_ser = serializer.serialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", len)?;
9125 if let Some(v) = self.status.as_ref() {
9126 struct_ser.serialize_field("status", v)?;
9127 }
9128 struct_ser.end()
9129 }
9130}
9131impl<'de> serde::Deserialize<'de> for ExpireIcebergTableSnapshotsResponse {
9132 #[allow(deprecated)]
9133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9134 where
9135 D: serde::Deserializer<'de>,
9136 {
9137 const FIELDS: &[&str] = &[
9138 "status",
9139 ];
9140
9141 #[allow(clippy::enum_variant_names)]
9142 enum GeneratedField {
9143 Status,
9144 }
9145 impl<'de> serde::Deserialize<'de> for GeneratedField {
9146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9147 where
9148 D: serde::Deserializer<'de>,
9149 {
9150 struct GeneratedVisitor;
9151
9152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9153 type Value = GeneratedField;
9154
9155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9156 write!(formatter, "expected one of: {:?}", &FIELDS)
9157 }
9158
9159 #[allow(unused_variables)]
9160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9161 where
9162 E: serde::de::Error,
9163 {
9164 match value {
9165 "status" => Ok(GeneratedField::Status),
9166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9167 }
9168 }
9169 }
9170 deserializer.deserialize_identifier(GeneratedVisitor)
9171 }
9172 }
9173 struct GeneratedVisitor;
9174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9175 type Value = ExpireIcebergTableSnapshotsResponse;
9176
9177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9178 formatter.write_str("struct ddl_service.ExpireIcebergTableSnapshotsResponse")
9179 }
9180
9181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpireIcebergTableSnapshotsResponse, V::Error>
9182 where
9183 V: serde::de::MapAccess<'de>,
9184 {
9185 let mut status__ = None;
9186 while let Some(k) = map_.next_key()? {
9187 match k {
9188 GeneratedField::Status => {
9189 if status__.is_some() {
9190 return Err(serde::de::Error::duplicate_field("status"));
9191 }
9192 status__ = map_.next_value()?;
9193 }
9194 }
9195 }
9196 Ok(ExpireIcebergTableSnapshotsResponse {
9197 status: status__,
9198 })
9199 }
9200 }
9201 deserializer.deserialize_struct("ddl_service.ExpireIcebergTableSnapshotsResponse", FIELDS, GeneratedVisitor)
9202 }
9203}
9204impl serde::Serialize for GetDdlProgressRequest {
9205 #[allow(deprecated)]
9206 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9207 where
9208 S: serde::Serializer,
9209 {
9210 use serde::ser::SerializeStruct;
9211 let len = 0;
9212 let struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressRequest", len)?;
9213 struct_ser.end()
9214 }
9215}
9216impl<'de> serde::Deserialize<'de> for GetDdlProgressRequest {
9217 #[allow(deprecated)]
9218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9219 where
9220 D: serde::Deserializer<'de>,
9221 {
9222 const FIELDS: &[&str] = &[
9223 ];
9224
9225 #[allow(clippy::enum_variant_names)]
9226 enum GeneratedField {
9227 }
9228 impl<'de> serde::Deserialize<'de> for GeneratedField {
9229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9230 where
9231 D: serde::Deserializer<'de>,
9232 {
9233 struct GeneratedVisitor;
9234
9235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9236 type Value = GeneratedField;
9237
9238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9239 write!(formatter, "expected one of: {:?}", &FIELDS)
9240 }
9241
9242 #[allow(unused_variables)]
9243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9244 where
9245 E: serde::de::Error,
9246 {
9247 Err(serde::de::Error::unknown_field(value, FIELDS))
9248 }
9249 }
9250 deserializer.deserialize_identifier(GeneratedVisitor)
9251 }
9252 }
9253 struct GeneratedVisitor;
9254 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9255 type Value = GetDdlProgressRequest;
9256
9257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9258 formatter.write_str("struct ddl_service.GetDdlProgressRequest")
9259 }
9260
9261 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressRequest, V::Error>
9262 where
9263 V: serde::de::MapAccess<'de>,
9264 {
9265 while map_.next_key::<GeneratedField>()?.is_some() {
9266 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9267 }
9268 Ok(GetDdlProgressRequest {
9269 })
9270 }
9271 }
9272 deserializer.deserialize_struct("ddl_service.GetDdlProgressRequest", FIELDS, GeneratedVisitor)
9273 }
9274}
9275impl serde::Serialize for GetDdlProgressResponse {
9276 #[allow(deprecated)]
9277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9278 where
9279 S: serde::Serializer,
9280 {
9281 use serde::ser::SerializeStruct;
9282 let mut len = 0;
9283 if !self.ddl_progress.is_empty() {
9284 len += 1;
9285 }
9286 let mut struct_ser = serializer.serialize_struct("ddl_service.GetDdlProgressResponse", len)?;
9287 if !self.ddl_progress.is_empty() {
9288 struct_ser.serialize_field("ddlProgress", &self.ddl_progress)?;
9289 }
9290 struct_ser.end()
9291 }
9292}
9293impl<'de> serde::Deserialize<'de> for GetDdlProgressResponse {
9294 #[allow(deprecated)]
9295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9296 where
9297 D: serde::Deserializer<'de>,
9298 {
9299 const FIELDS: &[&str] = &[
9300 "ddl_progress",
9301 "ddlProgress",
9302 ];
9303
9304 #[allow(clippy::enum_variant_names)]
9305 enum GeneratedField {
9306 DdlProgress,
9307 }
9308 impl<'de> serde::Deserialize<'de> for GeneratedField {
9309 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9310 where
9311 D: serde::Deserializer<'de>,
9312 {
9313 struct GeneratedVisitor;
9314
9315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9316 type Value = GeneratedField;
9317
9318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9319 write!(formatter, "expected one of: {:?}", &FIELDS)
9320 }
9321
9322 #[allow(unused_variables)]
9323 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9324 where
9325 E: serde::de::Error,
9326 {
9327 match value {
9328 "ddlProgress" | "ddl_progress" => Ok(GeneratedField::DdlProgress),
9329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9330 }
9331 }
9332 }
9333 deserializer.deserialize_identifier(GeneratedVisitor)
9334 }
9335 }
9336 struct GeneratedVisitor;
9337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9338 type Value = GetDdlProgressResponse;
9339
9340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9341 formatter.write_str("struct ddl_service.GetDdlProgressResponse")
9342 }
9343
9344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDdlProgressResponse, V::Error>
9345 where
9346 V: serde::de::MapAccess<'de>,
9347 {
9348 let mut ddl_progress__ = None;
9349 while let Some(k) = map_.next_key()? {
9350 match k {
9351 GeneratedField::DdlProgress => {
9352 if ddl_progress__.is_some() {
9353 return Err(serde::de::Error::duplicate_field("ddlProgress"));
9354 }
9355 ddl_progress__ = Some(map_.next_value()?);
9356 }
9357 }
9358 }
9359 Ok(GetDdlProgressResponse {
9360 ddl_progress: ddl_progress__.unwrap_or_default(),
9361 })
9362 }
9363 }
9364 deserializer.deserialize_struct("ddl_service.GetDdlProgressResponse", FIELDS, GeneratedVisitor)
9365 }
9366}
9367impl serde::Serialize for GetTableRequest {
9368 #[allow(deprecated)]
9369 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9370 where
9371 S: serde::Serializer,
9372 {
9373 use serde::ser::SerializeStruct;
9374 let mut len = 0;
9375 if !self.database_name.is_empty() {
9376 len += 1;
9377 }
9378 if !self.table_name.is_empty() {
9379 len += 1;
9380 }
9381 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableRequest", len)?;
9382 if !self.database_name.is_empty() {
9383 struct_ser.serialize_field("databaseName", &self.database_name)?;
9384 }
9385 if !self.table_name.is_empty() {
9386 struct_ser.serialize_field("tableName", &self.table_name)?;
9387 }
9388 struct_ser.end()
9389 }
9390}
9391impl<'de> serde::Deserialize<'de> for GetTableRequest {
9392 #[allow(deprecated)]
9393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9394 where
9395 D: serde::Deserializer<'de>,
9396 {
9397 const FIELDS: &[&str] = &[
9398 "database_name",
9399 "databaseName",
9400 "table_name",
9401 "tableName",
9402 ];
9403
9404 #[allow(clippy::enum_variant_names)]
9405 enum GeneratedField {
9406 DatabaseName,
9407 TableName,
9408 }
9409 impl<'de> serde::Deserialize<'de> for GeneratedField {
9410 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9411 where
9412 D: serde::Deserializer<'de>,
9413 {
9414 struct GeneratedVisitor;
9415
9416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9417 type Value = GeneratedField;
9418
9419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9420 write!(formatter, "expected one of: {:?}", &FIELDS)
9421 }
9422
9423 #[allow(unused_variables)]
9424 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9425 where
9426 E: serde::de::Error,
9427 {
9428 match value {
9429 "databaseName" | "database_name" => Ok(GeneratedField::DatabaseName),
9430 "tableName" | "table_name" => Ok(GeneratedField::TableName),
9431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9432 }
9433 }
9434 }
9435 deserializer.deserialize_identifier(GeneratedVisitor)
9436 }
9437 }
9438 struct GeneratedVisitor;
9439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9440 type Value = GetTableRequest;
9441
9442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9443 formatter.write_str("struct ddl_service.GetTableRequest")
9444 }
9445
9446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableRequest, V::Error>
9447 where
9448 V: serde::de::MapAccess<'de>,
9449 {
9450 let mut database_name__ = None;
9451 let mut table_name__ = None;
9452 while let Some(k) = map_.next_key()? {
9453 match k {
9454 GeneratedField::DatabaseName => {
9455 if database_name__.is_some() {
9456 return Err(serde::de::Error::duplicate_field("databaseName"));
9457 }
9458 database_name__ = Some(map_.next_value()?);
9459 }
9460 GeneratedField::TableName => {
9461 if table_name__.is_some() {
9462 return Err(serde::de::Error::duplicate_field("tableName"));
9463 }
9464 table_name__ = Some(map_.next_value()?);
9465 }
9466 }
9467 }
9468 Ok(GetTableRequest {
9469 database_name: database_name__.unwrap_or_default(),
9470 table_name: table_name__.unwrap_or_default(),
9471 })
9472 }
9473 }
9474 deserializer.deserialize_struct("ddl_service.GetTableRequest", FIELDS, GeneratedVisitor)
9475 }
9476}
9477impl serde::Serialize for GetTableResponse {
9478 #[allow(deprecated)]
9479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9480 where
9481 S: serde::Serializer,
9482 {
9483 use serde::ser::SerializeStruct;
9484 let mut len = 0;
9485 if self.table.is_some() {
9486 len += 1;
9487 }
9488 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTableResponse", len)?;
9489 if let Some(v) = self.table.as_ref() {
9490 struct_ser.serialize_field("table", v)?;
9491 }
9492 struct_ser.end()
9493 }
9494}
9495impl<'de> serde::Deserialize<'de> for GetTableResponse {
9496 #[allow(deprecated)]
9497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9498 where
9499 D: serde::Deserializer<'de>,
9500 {
9501 const FIELDS: &[&str] = &[
9502 "table",
9503 ];
9504
9505 #[allow(clippy::enum_variant_names)]
9506 enum GeneratedField {
9507 Table,
9508 }
9509 impl<'de> serde::Deserialize<'de> for GeneratedField {
9510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511 where
9512 D: serde::Deserializer<'de>,
9513 {
9514 struct GeneratedVisitor;
9515
9516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517 type Value = GeneratedField;
9518
9519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520 write!(formatter, "expected one of: {:?}", &FIELDS)
9521 }
9522
9523 #[allow(unused_variables)]
9524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525 where
9526 E: serde::de::Error,
9527 {
9528 match value {
9529 "table" => Ok(GeneratedField::Table),
9530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9531 }
9532 }
9533 }
9534 deserializer.deserialize_identifier(GeneratedVisitor)
9535 }
9536 }
9537 struct GeneratedVisitor;
9538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9539 type Value = GetTableResponse;
9540
9541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9542 formatter.write_str("struct ddl_service.GetTableResponse")
9543 }
9544
9545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableResponse, V::Error>
9546 where
9547 V: serde::de::MapAccess<'de>,
9548 {
9549 let mut table__ = None;
9550 while let Some(k) = map_.next_key()? {
9551 match k {
9552 GeneratedField::Table => {
9553 if table__.is_some() {
9554 return Err(serde::de::Error::duplicate_field("table"));
9555 }
9556 table__ = map_.next_value()?;
9557 }
9558 }
9559 }
9560 Ok(GetTableResponse {
9561 table: table__,
9562 })
9563 }
9564 }
9565 deserializer.deserialize_struct("ddl_service.GetTableResponse", FIELDS, GeneratedVisitor)
9566 }
9567}
9568impl serde::Serialize for GetTablesRequest {
9569 #[allow(deprecated)]
9570 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9571 where
9572 S: serde::Serializer,
9573 {
9574 use serde::ser::SerializeStruct;
9575 let mut len = 0;
9576 if !self.table_ids.is_empty() {
9577 len += 1;
9578 }
9579 if self.include_dropped_tables {
9580 len += 1;
9581 }
9582 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesRequest", len)?;
9583 if !self.table_ids.is_empty() {
9584 struct_ser.serialize_field("tableIds", &self.table_ids)?;
9585 }
9586 if self.include_dropped_tables {
9587 struct_ser.serialize_field("includeDroppedTables", &self.include_dropped_tables)?;
9588 }
9589 struct_ser.end()
9590 }
9591}
9592impl<'de> serde::Deserialize<'de> for GetTablesRequest {
9593 #[allow(deprecated)]
9594 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9595 where
9596 D: serde::Deserializer<'de>,
9597 {
9598 const FIELDS: &[&str] = &[
9599 "table_ids",
9600 "tableIds",
9601 "include_dropped_tables",
9602 "includeDroppedTables",
9603 ];
9604
9605 #[allow(clippy::enum_variant_names)]
9606 enum GeneratedField {
9607 TableIds,
9608 IncludeDroppedTables,
9609 }
9610 impl<'de> serde::Deserialize<'de> for GeneratedField {
9611 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9612 where
9613 D: serde::Deserializer<'de>,
9614 {
9615 struct GeneratedVisitor;
9616
9617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9618 type Value = GeneratedField;
9619
9620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9621 write!(formatter, "expected one of: {:?}", &FIELDS)
9622 }
9623
9624 #[allow(unused_variables)]
9625 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9626 where
9627 E: serde::de::Error,
9628 {
9629 match value {
9630 "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
9631 "includeDroppedTables" | "include_dropped_tables" => Ok(GeneratedField::IncludeDroppedTables),
9632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9633 }
9634 }
9635 }
9636 deserializer.deserialize_identifier(GeneratedVisitor)
9637 }
9638 }
9639 struct GeneratedVisitor;
9640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9641 type Value = GetTablesRequest;
9642
9643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9644 formatter.write_str("struct ddl_service.GetTablesRequest")
9645 }
9646
9647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesRequest, V::Error>
9648 where
9649 V: serde::de::MapAccess<'de>,
9650 {
9651 let mut table_ids__ = None;
9652 let mut include_dropped_tables__ = None;
9653 while let Some(k) = map_.next_key()? {
9654 match k {
9655 GeneratedField::TableIds => {
9656 if table_ids__.is_some() {
9657 return Err(serde::de::Error::duplicate_field("tableIds"));
9658 }
9659 table_ids__ =
9660 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9661 .into_iter().map(|x| x.0).collect())
9662 ;
9663 }
9664 GeneratedField::IncludeDroppedTables => {
9665 if include_dropped_tables__.is_some() {
9666 return Err(serde::de::Error::duplicate_field("includeDroppedTables"));
9667 }
9668 include_dropped_tables__ = Some(map_.next_value()?);
9669 }
9670 }
9671 }
9672 Ok(GetTablesRequest {
9673 table_ids: table_ids__.unwrap_or_default(),
9674 include_dropped_tables: include_dropped_tables__.unwrap_or_default(),
9675 })
9676 }
9677 }
9678 deserializer.deserialize_struct("ddl_service.GetTablesRequest", FIELDS, GeneratedVisitor)
9679 }
9680}
9681impl serde::Serialize for GetTablesResponse {
9682 #[allow(deprecated)]
9683 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9684 where
9685 S: serde::Serializer,
9686 {
9687 use serde::ser::SerializeStruct;
9688 let mut len = 0;
9689 if !self.tables.is_empty() {
9690 len += 1;
9691 }
9692 let mut struct_ser = serializer.serialize_struct("ddl_service.GetTablesResponse", len)?;
9693 if !self.tables.is_empty() {
9694 struct_ser.serialize_field("tables", &self.tables)?;
9695 }
9696 struct_ser.end()
9697 }
9698}
9699impl<'de> serde::Deserialize<'de> for GetTablesResponse {
9700 #[allow(deprecated)]
9701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9702 where
9703 D: serde::Deserializer<'de>,
9704 {
9705 const FIELDS: &[&str] = &[
9706 "tables",
9707 ];
9708
9709 #[allow(clippy::enum_variant_names)]
9710 enum GeneratedField {
9711 Tables,
9712 }
9713 impl<'de> serde::Deserialize<'de> for GeneratedField {
9714 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9715 where
9716 D: serde::Deserializer<'de>,
9717 {
9718 struct GeneratedVisitor;
9719
9720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9721 type Value = GeneratedField;
9722
9723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9724 write!(formatter, "expected one of: {:?}", &FIELDS)
9725 }
9726
9727 #[allow(unused_variables)]
9728 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9729 where
9730 E: serde::de::Error,
9731 {
9732 match value {
9733 "tables" => Ok(GeneratedField::Tables),
9734 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9735 }
9736 }
9737 }
9738 deserializer.deserialize_identifier(GeneratedVisitor)
9739 }
9740 }
9741 struct GeneratedVisitor;
9742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9743 type Value = GetTablesResponse;
9744
9745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9746 formatter.write_str("struct ddl_service.GetTablesResponse")
9747 }
9748
9749 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTablesResponse, V::Error>
9750 where
9751 V: serde::de::MapAccess<'de>,
9752 {
9753 let mut tables__ = None;
9754 while let Some(k) = map_.next_key()? {
9755 match k {
9756 GeneratedField::Tables => {
9757 if tables__.is_some() {
9758 return Err(serde::de::Error::duplicate_field("tables"));
9759 }
9760 tables__ = Some(
9761 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9762 .into_iter().map(|(k,v)| (k.0, v)).collect()
9763 );
9764 }
9765 }
9766 }
9767 Ok(GetTablesResponse {
9768 tables: tables__.unwrap_or_default(),
9769 })
9770 }
9771 }
9772 deserializer.deserialize_struct("ddl_service.GetTablesResponse", FIELDS, GeneratedVisitor)
9773 }
9774}
9775impl serde::Serialize for ListConnectionsRequest {
9776 #[allow(deprecated)]
9777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9778 where
9779 S: serde::Serializer,
9780 {
9781 use serde::ser::SerializeStruct;
9782 let len = 0;
9783 let struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsRequest", len)?;
9784 struct_ser.end()
9785 }
9786}
9787impl<'de> serde::Deserialize<'de> for ListConnectionsRequest {
9788 #[allow(deprecated)]
9789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9790 where
9791 D: serde::Deserializer<'de>,
9792 {
9793 const FIELDS: &[&str] = &[
9794 ];
9795
9796 #[allow(clippy::enum_variant_names)]
9797 enum GeneratedField {
9798 }
9799 impl<'de> serde::Deserialize<'de> for GeneratedField {
9800 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9801 where
9802 D: serde::Deserializer<'de>,
9803 {
9804 struct GeneratedVisitor;
9805
9806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9807 type Value = GeneratedField;
9808
9809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9810 write!(formatter, "expected one of: {:?}", &FIELDS)
9811 }
9812
9813 #[allow(unused_variables)]
9814 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9815 where
9816 E: serde::de::Error,
9817 {
9818 Err(serde::de::Error::unknown_field(value, FIELDS))
9819 }
9820 }
9821 deserializer.deserialize_identifier(GeneratedVisitor)
9822 }
9823 }
9824 struct GeneratedVisitor;
9825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9826 type Value = ListConnectionsRequest;
9827
9828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9829 formatter.write_str("struct ddl_service.ListConnectionsRequest")
9830 }
9831
9832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsRequest, V::Error>
9833 where
9834 V: serde::de::MapAccess<'de>,
9835 {
9836 while map_.next_key::<GeneratedField>()?.is_some() {
9837 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9838 }
9839 Ok(ListConnectionsRequest {
9840 })
9841 }
9842 }
9843 deserializer.deserialize_struct("ddl_service.ListConnectionsRequest", FIELDS, GeneratedVisitor)
9844 }
9845}
9846impl serde::Serialize for ListConnectionsResponse {
9847 #[allow(deprecated)]
9848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9849 where
9850 S: serde::Serializer,
9851 {
9852 use serde::ser::SerializeStruct;
9853 let mut len = 0;
9854 if !self.connections.is_empty() {
9855 len += 1;
9856 }
9857 let mut struct_ser = serializer.serialize_struct("ddl_service.ListConnectionsResponse", len)?;
9858 if !self.connections.is_empty() {
9859 struct_ser.serialize_field("connections", &self.connections)?;
9860 }
9861 struct_ser.end()
9862 }
9863}
9864impl<'de> serde::Deserialize<'de> for ListConnectionsResponse {
9865 #[allow(deprecated)]
9866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9867 where
9868 D: serde::Deserializer<'de>,
9869 {
9870 const FIELDS: &[&str] = &[
9871 "connections",
9872 ];
9873
9874 #[allow(clippy::enum_variant_names)]
9875 enum GeneratedField {
9876 Connections,
9877 }
9878 impl<'de> serde::Deserialize<'de> for GeneratedField {
9879 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9880 where
9881 D: serde::Deserializer<'de>,
9882 {
9883 struct GeneratedVisitor;
9884
9885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9886 type Value = GeneratedField;
9887
9888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9889 write!(formatter, "expected one of: {:?}", &FIELDS)
9890 }
9891
9892 #[allow(unused_variables)]
9893 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9894 where
9895 E: serde::de::Error,
9896 {
9897 match value {
9898 "connections" => Ok(GeneratedField::Connections),
9899 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9900 }
9901 }
9902 }
9903 deserializer.deserialize_identifier(GeneratedVisitor)
9904 }
9905 }
9906 struct GeneratedVisitor;
9907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9908 type Value = ListConnectionsResponse;
9909
9910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9911 formatter.write_str("struct ddl_service.ListConnectionsResponse")
9912 }
9913
9914 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListConnectionsResponse, V::Error>
9915 where
9916 V: serde::de::MapAccess<'de>,
9917 {
9918 let mut connections__ = None;
9919 while let Some(k) = map_.next_key()? {
9920 match k {
9921 GeneratedField::Connections => {
9922 if connections__.is_some() {
9923 return Err(serde::de::Error::duplicate_field("connections"));
9924 }
9925 connections__ = Some(map_.next_value()?);
9926 }
9927 }
9928 }
9929 Ok(ListConnectionsResponse {
9930 connections: connections__.unwrap_or_default(),
9931 })
9932 }
9933 }
9934 deserializer.deserialize_struct("ddl_service.ListConnectionsResponse", FIELDS, GeneratedVisitor)
9935 }
9936}
9937impl serde::Serialize for ReplaceJobPlan {
9938 #[allow(deprecated)]
9939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9940 where
9941 S: serde::Serializer,
9942 {
9943 use serde::ser::SerializeStruct;
9944 let mut len = 0;
9945 if self.fragment_graph.is_some() {
9946 len += 1;
9947 }
9948 if self.replace_job.is_some() {
9949 len += 1;
9950 }
9951 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan", len)?;
9952 if let Some(v) = self.fragment_graph.as_ref() {
9953 struct_ser.serialize_field("fragmentGraph", v)?;
9954 }
9955 if let Some(v) = self.replace_job.as_ref() {
9956 match v {
9957 replace_job_plan::ReplaceJob::ReplaceTable(v) => {
9958 struct_ser.serialize_field("replaceTable", v)?;
9959 }
9960 replace_job_plan::ReplaceJob::ReplaceSource(v) => {
9961 struct_ser.serialize_field("replaceSource", v)?;
9962 }
9963 replace_job_plan::ReplaceJob::ReplaceMaterializedView(v) => {
9964 struct_ser.serialize_field("replaceMaterializedView", v)?;
9965 }
9966 }
9967 }
9968 struct_ser.end()
9969 }
9970}
9971impl<'de> serde::Deserialize<'de> for ReplaceJobPlan {
9972 #[allow(deprecated)]
9973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9974 where
9975 D: serde::Deserializer<'de>,
9976 {
9977 const FIELDS: &[&str] = &[
9978 "fragment_graph",
9979 "fragmentGraph",
9980 "replace_table",
9981 "replaceTable",
9982 "replace_source",
9983 "replaceSource",
9984 "replace_materialized_view",
9985 "replaceMaterializedView",
9986 ];
9987
9988 #[allow(clippy::enum_variant_names)]
9989 enum GeneratedField {
9990 FragmentGraph,
9991 ReplaceTable,
9992 ReplaceSource,
9993 ReplaceMaterializedView,
9994 }
9995 impl<'de> serde::Deserialize<'de> for GeneratedField {
9996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9997 where
9998 D: serde::Deserializer<'de>,
9999 {
10000 struct GeneratedVisitor;
10001
10002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10003 type Value = GeneratedField;
10004
10005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10006 write!(formatter, "expected one of: {:?}", &FIELDS)
10007 }
10008
10009 #[allow(unused_variables)]
10010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10011 where
10012 E: serde::de::Error,
10013 {
10014 match value {
10015 "fragmentGraph" | "fragment_graph" => Ok(GeneratedField::FragmentGraph),
10016 "replaceTable" | "replace_table" => Ok(GeneratedField::ReplaceTable),
10017 "replaceSource" | "replace_source" => Ok(GeneratedField::ReplaceSource),
10018 "replaceMaterializedView" | "replace_materialized_view" => Ok(GeneratedField::ReplaceMaterializedView),
10019 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10020 }
10021 }
10022 }
10023 deserializer.deserialize_identifier(GeneratedVisitor)
10024 }
10025 }
10026 struct GeneratedVisitor;
10027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10028 type Value = ReplaceJobPlan;
10029
10030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10031 formatter.write_str("struct ddl_service.ReplaceJobPlan")
10032 }
10033
10034 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlan, V::Error>
10035 where
10036 V: serde::de::MapAccess<'de>,
10037 {
10038 let mut fragment_graph__ = None;
10039 let mut replace_job__ = None;
10040 while let Some(k) = map_.next_key()? {
10041 match k {
10042 GeneratedField::FragmentGraph => {
10043 if fragment_graph__.is_some() {
10044 return Err(serde::de::Error::duplicate_field("fragmentGraph"));
10045 }
10046 fragment_graph__ = map_.next_value()?;
10047 }
10048 GeneratedField::ReplaceTable => {
10049 if replace_job__.is_some() {
10050 return Err(serde::de::Error::duplicate_field("replaceTable"));
10051 }
10052 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceTable)
10053;
10054 }
10055 GeneratedField::ReplaceSource => {
10056 if replace_job__.is_some() {
10057 return Err(serde::de::Error::duplicate_field("replaceSource"));
10058 }
10059 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceSource)
10060;
10061 }
10062 GeneratedField::ReplaceMaterializedView => {
10063 if replace_job__.is_some() {
10064 return Err(serde::de::Error::duplicate_field("replaceMaterializedView"));
10065 }
10066 replace_job__ = map_.next_value::<::std::option::Option<_>>()?.map(replace_job_plan::ReplaceJob::ReplaceMaterializedView)
10067;
10068 }
10069 }
10070 }
10071 Ok(ReplaceJobPlan {
10072 fragment_graph: fragment_graph__,
10073 replace_job: replace_job__,
10074 })
10075 }
10076 }
10077 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan", FIELDS, GeneratedVisitor)
10078 }
10079}
10080impl serde::Serialize for replace_job_plan::ReplaceMaterializedView {
10081 #[allow(deprecated)]
10082 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10083 where
10084 S: serde::Serializer,
10085 {
10086 use serde::ser::SerializeStruct;
10087 let mut len = 0;
10088 if self.table.is_some() {
10089 len += 1;
10090 }
10091 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", len)?;
10092 if let Some(v) = self.table.as_ref() {
10093 struct_ser.serialize_field("table", v)?;
10094 }
10095 struct_ser.end()
10096 }
10097}
10098impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceMaterializedView {
10099 #[allow(deprecated)]
10100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10101 where
10102 D: serde::Deserializer<'de>,
10103 {
10104 const FIELDS: &[&str] = &[
10105 "table",
10106 ];
10107
10108 #[allow(clippy::enum_variant_names)]
10109 enum GeneratedField {
10110 Table,
10111 }
10112 impl<'de> serde::Deserialize<'de> for GeneratedField {
10113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10114 where
10115 D: serde::Deserializer<'de>,
10116 {
10117 struct GeneratedVisitor;
10118
10119 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10120 type Value = GeneratedField;
10121
10122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10123 write!(formatter, "expected one of: {:?}", &FIELDS)
10124 }
10125
10126 #[allow(unused_variables)]
10127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10128 where
10129 E: serde::de::Error,
10130 {
10131 match value {
10132 "table" => Ok(GeneratedField::Table),
10133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10134 }
10135 }
10136 }
10137 deserializer.deserialize_identifier(GeneratedVisitor)
10138 }
10139 }
10140 struct GeneratedVisitor;
10141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10142 type Value = replace_job_plan::ReplaceMaterializedView;
10143
10144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10145 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceMaterializedView")
10146 }
10147
10148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceMaterializedView, V::Error>
10149 where
10150 V: serde::de::MapAccess<'de>,
10151 {
10152 let mut table__ = None;
10153 while let Some(k) = map_.next_key()? {
10154 match k {
10155 GeneratedField::Table => {
10156 if table__.is_some() {
10157 return Err(serde::de::Error::duplicate_field("table"));
10158 }
10159 table__ = map_.next_value()?;
10160 }
10161 }
10162 }
10163 Ok(replace_job_plan::ReplaceMaterializedView {
10164 table: table__,
10165 })
10166 }
10167 }
10168 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceMaterializedView", FIELDS, GeneratedVisitor)
10169 }
10170}
10171impl serde::Serialize for replace_job_plan::ReplaceSource {
10172 #[allow(deprecated)]
10173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10174 where
10175 S: serde::Serializer,
10176 {
10177 use serde::ser::SerializeStruct;
10178 let mut len = 0;
10179 if self.source.is_some() {
10180 len += 1;
10181 }
10182 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", len)?;
10183 if let Some(v) = self.source.as_ref() {
10184 struct_ser.serialize_field("source", v)?;
10185 }
10186 struct_ser.end()
10187 }
10188}
10189impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceSource {
10190 #[allow(deprecated)]
10191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10192 where
10193 D: serde::Deserializer<'de>,
10194 {
10195 const FIELDS: &[&str] = &[
10196 "source",
10197 ];
10198
10199 #[allow(clippy::enum_variant_names)]
10200 enum GeneratedField {
10201 Source,
10202 }
10203 impl<'de> serde::Deserialize<'de> for GeneratedField {
10204 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10205 where
10206 D: serde::Deserializer<'de>,
10207 {
10208 struct GeneratedVisitor;
10209
10210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10211 type Value = GeneratedField;
10212
10213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10214 write!(formatter, "expected one of: {:?}", &FIELDS)
10215 }
10216
10217 #[allow(unused_variables)]
10218 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10219 where
10220 E: serde::de::Error,
10221 {
10222 match value {
10223 "source" => Ok(GeneratedField::Source),
10224 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10225 }
10226 }
10227 }
10228 deserializer.deserialize_identifier(GeneratedVisitor)
10229 }
10230 }
10231 struct GeneratedVisitor;
10232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10233 type Value = replace_job_plan::ReplaceSource;
10234
10235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10236 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceSource")
10237 }
10238
10239 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceSource, V::Error>
10240 where
10241 V: serde::de::MapAccess<'de>,
10242 {
10243 let mut source__ = None;
10244 while let Some(k) = map_.next_key()? {
10245 match k {
10246 GeneratedField::Source => {
10247 if source__.is_some() {
10248 return Err(serde::de::Error::duplicate_field("source"));
10249 }
10250 source__ = map_.next_value()?;
10251 }
10252 }
10253 }
10254 Ok(replace_job_plan::ReplaceSource {
10255 source: source__,
10256 })
10257 }
10258 }
10259 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceSource", FIELDS, GeneratedVisitor)
10260 }
10261}
10262impl serde::Serialize for replace_job_plan::ReplaceTable {
10263 #[allow(deprecated)]
10264 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10265 where
10266 S: serde::Serializer,
10267 {
10268 use serde::ser::SerializeStruct;
10269 let mut len = 0;
10270 if self.table.is_some() {
10271 len += 1;
10272 }
10273 if self.source.is_some() {
10274 len += 1;
10275 }
10276 if self.job_type != 0 {
10277 len += 1;
10278 }
10279 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", len)?;
10280 if let Some(v) = self.table.as_ref() {
10281 struct_ser.serialize_field("table", v)?;
10282 }
10283 if let Some(v) = self.source.as_ref() {
10284 struct_ser.serialize_field("source", v)?;
10285 }
10286 if self.job_type != 0 {
10287 let v = TableJobType::try_from(self.job_type)
10288 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.job_type)))?;
10289 struct_ser.serialize_field("jobType", &v)?;
10290 }
10291 struct_ser.end()
10292 }
10293}
10294impl<'de> serde::Deserialize<'de> for replace_job_plan::ReplaceTable {
10295 #[allow(deprecated)]
10296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10297 where
10298 D: serde::Deserializer<'de>,
10299 {
10300 const FIELDS: &[&str] = &[
10301 "table",
10302 "source",
10303 "job_type",
10304 "jobType",
10305 ];
10306
10307 #[allow(clippy::enum_variant_names)]
10308 enum GeneratedField {
10309 Table,
10310 Source,
10311 JobType,
10312 }
10313 impl<'de> serde::Deserialize<'de> for GeneratedField {
10314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10315 where
10316 D: serde::Deserializer<'de>,
10317 {
10318 struct GeneratedVisitor;
10319
10320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10321 type Value = GeneratedField;
10322
10323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10324 write!(formatter, "expected one of: {:?}", &FIELDS)
10325 }
10326
10327 #[allow(unused_variables)]
10328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10329 where
10330 E: serde::de::Error,
10331 {
10332 match value {
10333 "table" => Ok(GeneratedField::Table),
10334 "source" => Ok(GeneratedField::Source),
10335 "jobType" | "job_type" => Ok(GeneratedField::JobType),
10336 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10337 }
10338 }
10339 }
10340 deserializer.deserialize_identifier(GeneratedVisitor)
10341 }
10342 }
10343 struct GeneratedVisitor;
10344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10345 type Value = replace_job_plan::ReplaceTable;
10346
10347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10348 formatter.write_str("struct ddl_service.ReplaceJobPlan.ReplaceTable")
10349 }
10350
10351 fn visit_map<V>(self, mut map_: V) -> std::result::Result<replace_job_plan::ReplaceTable, V::Error>
10352 where
10353 V: serde::de::MapAccess<'de>,
10354 {
10355 let mut table__ = None;
10356 let mut source__ = None;
10357 let mut job_type__ = None;
10358 while let Some(k) = map_.next_key()? {
10359 match k {
10360 GeneratedField::Table => {
10361 if table__.is_some() {
10362 return Err(serde::de::Error::duplicate_field("table"));
10363 }
10364 table__ = map_.next_value()?;
10365 }
10366 GeneratedField::Source => {
10367 if source__.is_some() {
10368 return Err(serde::de::Error::duplicate_field("source"));
10369 }
10370 source__ = map_.next_value()?;
10371 }
10372 GeneratedField::JobType => {
10373 if job_type__.is_some() {
10374 return Err(serde::de::Error::duplicate_field("jobType"));
10375 }
10376 job_type__ = Some(map_.next_value::<TableJobType>()? as i32);
10377 }
10378 }
10379 }
10380 Ok(replace_job_plan::ReplaceTable {
10381 table: table__,
10382 source: source__,
10383 job_type: job_type__.unwrap_or_default(),
10384 })
10385 }
10386 }
10387 deserializer.deserialize_struct("ddl_service.ReplaceJobPlan.ReplaceTable", FIELDS, GeneratedVisitor)
10388 }
10389}
10390impl serde::Serialize for ReplaceJobPlanRequest {
10391 #[allow(deprecated)]
10392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10393 where
10394 S: serde::Serializer,
10395 {
10396 use serde::ser::SerializeStruct;
10397 let mut len = 0;
10398 if self.plan.is_some() {
10399 len += 1;
10400 }
10401 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanRequest", len)?;
10402 if let Some(v) = self.plan.as_ref() {
10403 struct_ser.serialize_field("plan", v)?;
10404 }
10405 struct_ser.end()
10406 }
10407}
10408impl<'de> serde::Deserialize<'de> for ReplaceJobPlanRequest {
10409 #[allow(deprecated)]
10410 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10411 where
10412 D: serde::Deserializer<'de>,
10413 {
10414 const FIELDS: &[&str] = &[
10415 "plan",
10416 ];
10417
10418 #[allow(clippy::enum_variant_names)]
10419 enum GeneratedField {
10420 Plan,
10421 }
10422 impl<'de> serde::Deserialize<'de> for GeneratedField {
10423 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10424 where
10425 D: serde::Deserializer<'de>,
10426 {
10427 struct GeneratedVisitor;
10428
10429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10430 type Value = GeneratedField;
10431
10432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10433 write!(formatter, "expected one of: {:?}", &FIELDS)
10434 }
10435
10436 #[allow(unused_variables)]
10437 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10438 where
10439 E: serde::de::Error,
10440 {
10441 match value {
10442 "plan" => Ok(GeneratedField::Plan),
10443 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10444 }
10445 }
10446 }
10447 deserializer.deserialize_identifier(GeneratedVisitor)
10448 }
10449 }
10450 struct GeneratedVisitor;
10451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10452 type Value = ReplaceJobPlanRequest;
10453
10454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10455 formatter.write_str("struct ddl_service.ReplaceJobPlanRequest")
10456 }
10457
10458 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanRequest, V::Error>
10459 where
10460 V: serde::de::MapAccess<'de>,
10461 {
10462 let mut plan__ = None;
10463 while let Some(k) = map_.next_key()? {
10464 match k {
10465 GeneratedField::Plan => {
10466 if plan__.is_some() {
10467 return Err(serde::de::Error::duplicate_field("plan"));
10468 }
10469 plan__ = map_.next_value()?;
10470 }
10471 }
10472 }
10473 Ok(ReplaceJobPlanRequest {
10474 plan: plan__,
10475 })
10476 }
10477 }
10478 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanRequest", FIELDS, GeneratedVisitor)
10479 }
10480}
10481impl serde::Serialize for ReplaceJobPlanResponse {
10482 #[allow(deprecated)]
10483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10484 where
10485 S: serde::Serializer,
10486 {
10487 use serde::ser::SerializeStruct;
10488 let mut len = 0;
10489 if self.status.is_some() {
10490 len += 1;
10491 }
10492 if self.version.is_some() {
10493 len += 1;
10494 }
10495 let mut struct_ser = serializer.serialize_struct("ddl_service.ReplaceJobPlanResponse", len)?;
10496 if let Some(v) = self.status.as_ref() {
10497 struct_ser.serialize_field("status", v)?;
10498 }
10499 if let Some(v) = self.version.as_ref() {
10500 struct_ser.serialize_field("version", v)?;
10501 }
10502 struct_ser.end()
10503 }
10504}
10505impl<'de> serde::Deserialize<'de> for ReplaceJobPlanResponse {
10506 #[allow(deprecated)]
10507 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10508 where
10509 D: serde::Deserializer<'de>,
10510 {
10511 const FIELDS: &[&str] = &[
10512 "status",
10513 "version",
10514 ];
10515
10516 #[allow(clippy::enum_variant_names)]
10517 enum GeneratedField {
10518 Status,
10519 Version,
10520 }
10521 impl<'de> serde::Deserialize<'de> for GeneratedField {
10522 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10523 where
10524 D: serde::Deserializer<'de>,
10525 {
10526 struct GeneratedVisitor;
10527
10528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10529 type Value = GeneratedField;
10530
10531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10532 write!(formatter, "expected one of: {:?}", &FIELDS)
10533 }
10534
10535 #[allow(unused_variables)]
10536 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10537 where
10538 E: serde::de::Error,
10539 {
10540 match value {
10541 "status" => Ok(GeneratedField::Status),
10542 "version" => Ok(GeneratedField::Version),
10543 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10544 }
10545 }
10546 }
10547 deserializer.deserialize_identifier(GeneratedVisitor)
10548 }
10549 }
10550 struct GeneratedVisitor;
10551 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10552 type Value = ReplaceJobPlanResponse;
10553
10554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10555 formatter.write_str("struct ddl_service.ReplaceJobPlanResponse")
10556 }
10557
10558 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplaceJobPlanResponse, V::Error>
10559 where
10560 V: serde::de::MapAccess<'de>,
10561 {
10562 let mut status__ = None;
10563 let mut version__ = None;
10564 while let Some(k) = map_.next_key()? {
10565 match k {
10566 GeneratedField::Status => {
10567 if status__.is_some() {
10568 return Err(serde::de::Error::duplicate_field("status"));
10569 }
10570 status__ = map_.next_value()?;
10571 }
10572 GeneratedField::Version => {
10573 if version__.is_some() {
10574 return Err(serde::de::Error::duplicate_field("version"));
10575 }
10576 version__ = map_.next_value()?;
10577 }
10578 }
10579 }
10580 Ok(ReplaceJobPlanResponse {
10581 status: status__,
10582 version: version__,
10583 })
10584 }
10585 }
10586 deserializer.deserialize_struct("ddl_service.ReplaceJobPlanResponse", FIELDS, GeneratedVisitor)
10587 }
10588}
10589impl serde::Serialize for RisectlListStateTablesRequest {
10590 #[allow(deprecated)]
10591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10592 where
10593 S: serde::Serializer,
10594 {
10595 use serde::ser::SerializeStruct;
10596 let len = 0;
10597 let struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesRequest", len)?;
10598 struct_ser.end()
10599 }
10600}
10601impl<'de> serde::Deserialize<'de> for RisectlListStateTablesRequest {
10602 #[allow(deprecated)]
10603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10604 where
10605 D: serde::Deserializer<'de>,
10606 {
10607 const FIELDS: &[&str] = &[
10608 ];
10609
10610 #[allow(clippy::enum_variant_names)]
10611 enum GeneratedField {
10612 }
10613 impl<'de> serde::Deserialize<'de> for GeneratedField {
10614 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10615 where
10616 D: serde::Deserializer<'de>,
10617 {
10618 struct GeneratedVisitor;
10619
10620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10621 type Value = GeneratedField;
10622
10623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10624 write!(formatter, "expected one of: {:?}", &FIELDS)
10625 }
10626
10627 #[allow(unused_variables)]
10628 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10629 where
10630 E: serde::de::Error,
10631 {
10632 Err(serde::de::Error::unknown_field(value, FIELDS))
10633 }
10634 }
10635 deserializer.deserialize_identifier(GeneratedVisitor)
10636 }
10637 }
10638 struct GeneratedVisitor;
10639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10640 type Value = RisectlListStateTablesRequest;
10641
10642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10643 formatter.write_str("struct ddl_service.RisectlListStateTablesRequest")
10644 }
10645
10646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesRequest, V::Error>
10647 where
10648 V: serde::de::MapAccess<'de>,
10649 {
10650 while map_.next_key::<GeneratedField>()?.is_some() {
10651 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10652 }
10653 Ok(RisectlListStateTablesRequest {
10654 })
10655 }
10656 }
10657 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesRequest", FIELDS, GeneratedVisitor)
10658 }
10659}
10660impl serde::Serialize for RisectlListStateTablesResponse {
10661 #[allow(deprecated)]
10662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10663 where
10664 S: serde::Serializer,
10665 {
10666 use serde::ser::SerializeStruct;
10667 let mut len = 0;
10668 if !self.tables.is_empty() {
10669 len += 1;
10670 }
10671 let mut struct_ser = serializer.serialize_struct("ddl_service.RisectlListStateTablesResponse", len)?;
10672 if !self.tables.is_empty() {
10673 struct_ser.serialize_field("tables", &self.tables)?;
10674 }
10675 struct_ser.end()
10676 }
10677}
10678impl<'de> serde::Deserialize<'de> for RisectlListStateTablesResponse {
10679 #[allow(deprecated)]
10680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10681 where
10682 D: serde::Deserializer<'de>,
10683 {
10684 const FIELDS: &[&str] = &[
10685 "tables",
10686 ];
10687
10688 #[allow(clippy::enum_variant_names)]
10689 enum GeneratedField {
10690 Tables,
10691 }
10692 impl<'de> serde::Deserialize<'de> for GeneratedField {
10693 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10694 where
10695 D: serde::Deserializer<'de>,
10696 {
10697 struct GeneratedVisitor;
10698
10699 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10700 type Value = GeneratedField;
10701
10702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10703 write!(formatter, "expected one of: {:?}", &FIELDS)
10704 }
10705
10706 #[allow(unused_variables)]
10707 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10708 where
10709 E: serde::de::Error,
10710 {
10711 match value {
10712 "tables" => Ok(GeneratedField::Tables),
10713 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10714 }
10715 }
10716 }
10717 deserializer.deserialize_identifier(GeneratedVisitor)
10718 }
10719 }
10720 struct GeneratedVisitor;
10721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10722 type Value = RisectlListStateTablesResponse;
10723
10724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10725 formatter.write_str("struct ddl_service.RisectlListStateTablesResponse")
10726 }
10727
10728 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RisectlListStateTablesResponse, V::Error>
10729 where
10730 V: serde::de::MapAccess<'de>,
10731 {
10732 let mut tables__ = None;
10733 while let Some(k) = map_.next_key()? {
10734 match k {
10735 GeneratedField::Tables => {
10736 if tables__.is_some() {
10737 return Err(serde::de::Error::duplicate_field("tables"));
10738 }
10739 tables__ = Some(map_.next_value()?);
10740 }
10741 }
10742 }
10743 Ok(RisectlListStateTablesResponse {
10744 tables: tables__.unwrap_or_default(),
10745 })
10746 }
10747 }
10748 deserializer.deserialize_struct("ddl_service.RisectlListStateTablesResponse", FIELDS, GeneratedVisitor)
10749 }
10750}
10751impl serde::Serialize for SchemaChangeEnvelope {
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.table_changes.is_empty() {
10760 len += 1;
10761 }
10762 let mut struct_ser = serializer.serialize_struct("ddl_service.SchemaChangeEnvelope", len)?;
10763 if !self.table_changes.is_empty() {
10764 struct_ser.serialize_field("tableChanges", &self.table_changes)?;
10765 }
10766 struct_ser.end()
10767 }
10768}
10769impl<'de> serde::Deserialize<'de> for SchemaChangeEnvelope {
10770 #[allow(deprecated)]
10771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10772 where
10773 D: serde::Deserializer<'de>,
10774 {
10775 const FIELDS: &[&str] = &[
10776 "table_changes",
10777 "tableChanges",
10778 ];
10779
10780 #[allow(clippy::enum_variant_names)]
10781 enum GeneratedField {
10782 TableChanges,
10783 }
10784 impl<'de> serde::Deserialize<'de> for GeneratedField {
10785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10786 where
10787 D: serde::Deserializer<'de>,
10788 {
10789 struct GeneratedVisitor;
10790
10791 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10792 type Value = GeneratedField;
10793
10794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10795 write!(formatter, "expected one of: {:?}", &FIELDS)
10796 }
10797
10798 #[allow(unused_variables)]
10799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10800 where
10801 E: serde::de::Error,
10802 {
10803 match value {
10804 "tableChanges" | "table_changes" => Ok(GeneratedField::TableChanges),
10805 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10806 }
10807 }
10808 }
10809 deserializer.deserialize_identifier(GeneratedVisitor)
10810 }
10811 }
10812 struct GeneratedVisitor;
10813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10814 type Value = SchemaChangeEnvelope;
10815
10816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10817 formatter.write_str("struct ddl_service.SchemaChangeEnvelope")
10818 }
10819
10820 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SchemaChangeEnvelope, V::Error>
10821 where
10822 V: serde::de::MapAccess<'de>,
10823 {
10824 let mut table_changes__ = None;
10825 while let Some(k) = map_.next_key()? {
10826 match k {
10827 GeneratedField::TableChanges => {
10828 if table_changes__.is_some() {
10829 return Err(serde::de::Error::duplicate_field("tableChanges"));
10830 }
10831 table_changes__ = Some(map_.next_value()?);
10832 }
10833 }
10834 }
10835 Ok(SchemaChangeEnvelope {
10836 table_changes: table_changes__.unwrap_or_default(),
10837 })
10838 }
10839 }
10840 deserializer.deserialize_struct("ddl_service.SchemaChangeEnvelope", FIELDS, GeneratedVisitor)
10841 }
10842}
10843impl serde::Serialize for TableJobType {
10844 #[allow(deprecated)]
10845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10846 where
10847 S: serde::Serializer,
10848 {
10849 let variant = match self {
10850 Self::Unspecified => "TABLE_JOB_TYPE_UNSPECIFIED",
10851 Self::General => "TABLE_JOB_TYPE_GENERAL",
10852 Self::SharedCdcSource => "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
10853 };
10854 serializer.serialize_str(variant)
10855 }
10856}
10857impl<'de> serde::Deserialize<'de> for TableJobType {
10858 #[allow(deprecated)]
10859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10860 where
10861 D: serde::Deserializer<'de>,
10862 {
10863 const FIELDS: &[&str] = &[
10864 "TABLE_JOB_TYPE_UNSPECIFIED",
10865 "TABLE_JOB_TYPE_GENERAL",
10866 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE",
10867 ];
10868
10869 struct GeneratedVisitor;
10870
10871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10872 type Value = TableJobType;
10873
10874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10875 write!(formatter, "expected one of: {:?}", &FIELDS)
10876 }
10877
10878 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10879 where
10880 E: serde::de::Error,
10881 {
10882 i32::try_from(v)
10883 .ok()
10884 .and_then(|x| x.try_into().ok())
10885 .ok_or_else(|| {
10886 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10887 })
10888 }
10889
10890 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10891 where
10892 E: serde::de::Error,
10893 {
10894 i32::try_from(v)
10895 .ok()
10896 .and_then(|x| x.try_into().ok())
10897 .ok_or_else(|| {
10898 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10899 })
10900 }
10901
10902 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10903 where
10904 E: serde::de::Error,
10905 {
10906 match value {
10907 "TABLE_JOB_TYPE_UNSPECIFIED" => Ok(TableJobType::Unspecified),
10908 "TABLE_JOB_TYPE_GENERAL" => Ok(TableJobType::General),
10909 "TABLE_JOB_TYPE_SHARED_CDC_SOURCE" => Ok(TableJobType::SharedCdcSource),
10910 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10911 }
10912 }
10913 }
10914 deserializer.deserialize_any(GeneratedVisitor)
10915 }
10916}
10917impl serde::Serialize for TableSchemaChange {
10918 #[allow(deprecated)]
10919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10920 where
10921 S: serde::Serializer,
10922 {
10923 use serde::ser::SerializeStruct;
10924 let mut len = 0;
10925 if self.change_type != 0 {
10926 len += 1;
10927 }
10928 if !self.cdc_table_id.is_empty() {
10929 len += 1;
10930 }
10931 if !self.columns.is_empty() {
10932 len += 1;
10933 }
10934 if !self.upstream_ddl.is_empty() {
10935 len += 1;
10936 }
10937 let mut struct_ser = serializer.serialize_struct("ddl_service.TableSchemaChange", len)?;
10938 if self.change_type != 0 {
10939 let v = table_schema_change::TableChangeType::try_from(self.change_type)
10940 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.change_type)))?;
10941 struct_ser.serialize_field("changeType", &v)?;
10942 }
10943 if !self.cdc_table_id.is_empty() {
10944 struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
10945 }
10946 if !self.columns.is_empty() {
10947 struct_ser.serialize_field("columns", &self.columns)?;
10948 }
10949 if !self.upstream_ddl.is_empty() {
10950 struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
10951 }
10952 struct_ser.end()
10953 }
10954}
10955impl<'de> serde::Deserialize<'de> for TableSchemaChange {
10956 #[allow(deprecated)]
10957 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10958 where
10959 D: serde::Deserializer<'de>,
10960 {
10961 const FIELDS: &[&str] = &[
10962 "change_type",
10963 "changeType",
10964 "cdc_table_id",
10965 "cdcTableId",
10966 "columns",
10967 "upstream_ddl",
10968 "upstreamDdl",
10969 ];
10970
10971 #[allow(clippy::enum_variant_names)]
10972 enum GeneratedField {
10973 ChangeType,
10974 CdcTableId,
10975 Columns,
10976 UpstreamDdl,
10977 }
10978 impl<'de> serde::Deserialize<'de> for GeneratedField {
10979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10980 where
10981 D: serde::Deserializer<'de>,
10982 {
10983 struct GeneratedVisitor;
10984
10985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10986 type Value = GeneratedField;
10987
10988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10989 write!(formatter, "expected one of: {:?}", &FIELDS)
10990 }
10991
10992 #[allow(unused_variables)]
10993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10994 where
10995 E: serde::de::Error,
10996 {
10997 match value {
10998 "changeType" | "change_type" => Ok(GeneratedField::ChangeType),
10999 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
11000 "columns" => Ok(GeneratedField::Columns),
11001 "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
11002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11003 }
11004 }
11005 }
11006 deserializer.deserialize_identifier(GeneratedVisitor)
11007 }
11008 }
11009 struct GeneratedVisitor;
11010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11011 type Value = TableSchemaChange;
11012
11013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11014 formatter.write_str("struct ddl_service.TableSchemaChange")
11015 }
11016
11017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchemaChange, V::Error>
11018 where
11019 V: serde::de::MapAccess<'de>,
11020 {
11021 let mut change_type__ = None;
11022 let mut cdc_table_id__ = None;
11023 let mut columns__ = None;
11024 let mut upstream_ddl__ = None;
11025 while let Some(k) = map_.next_key()? {
11026 match k {
11027 GeneratedField::ChangeType => {
11028 if change_type__.is_some() {
11029 return Err(serde::de::Error::duplicate_field("changeType"));
11030 }
11031 change_type__ = Some(map_.next_value::<table_schema_change::TableChangeType>()? as i32);
11032 }
11033 GeneratedField::CdcTableId => {
11034 if cdc_table_id__.is_some() {
11035 return Err(serde::de::Error::duplicate_field("cdcTableId"));
11036 }
11037 cdc_table_id__ = Some(map_.next_value()?);
11038 }
11039 GeneratedField::Columns => {
11040 if columns__.is_some() {
11041 return Err(serde::de::Error::duplicate_field("columns"));
11042 }
11043 columns__ = Some(map_.next_value()?);
11044 }
11045 GeneratedField::UpstreamDdl => {
11046 if upstream_ddl__.is_some() {
11047 return Err(serde::de::Error::duplicate_field("upstreamDdl"));
11048 }
11049 upstream_ddl__ = Some(map_.next_value()?);
11050 }
11051 }
11052 }
11053 Ok(TableSchemaChange {
11054 change_type: change_type__.unwrap_or_default(),
11055 cdc_table_id: cdc_table_id__.unwrap_or_default(),
11056 columns: columns__.unwrap_or_default(),
11057 upstream_ddl: upstream_ddl__.unwrap_or_default(),
11058 })
11059 }
11060 }
11061 deserializer.deserialize_struct("ddl_service.TableSchemaChange", FIELDS, GeneratedVisitor)
11062 }
11063}
11064impl serde::Serialize for table_schema_change::TableChangeType {
11065 #[allow(deprecated)]
11066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11067 where
11068 S: serde::Serializer,
11069 {
11070 let variant = match self {
11071 Self::Unspecified => "UNSPECIFIED",
11072 Self::Alter => "ALTER",
11073 Self::Create => "CREATE",
11074 Self::Drop => "DROP",
11075 };
11076 serializer.serialize_str(variant)
11077 }
11078}
11079impl<'de> serde::Deserialize<'de> for table_schema_change::TableChangeType {
11080 #[allow(deprecated)]
11081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11082 where
11083 D: serde::Deserializer<'de>,
11084 {
11085 const FIELDS: &[&str] = &[
11086 "UNSPECIFIED",
11087 "ALTER",
11088 "CREATE",
11089 "DROP",
11090 ];
11091
11092 struct GeneratedVisitor;
11093
11094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11095 type Value = table_schema_change::TableChangeType;
11096
11097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11098 write!(formatter, "expected one of: {:?}", &FIELDS)
11099 }
11100
11101 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11102 where
11103 E: serde::de::Error,
11104 {
11105 i32::try_from(v)
11106 .ok()
11107 .and_then(|x| x.try_into().ok())
11108 .ok_or_else(|| {
11109 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11110 })
11111 }
11112
11113 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11114 where
11115 E: serde::de::Error,
11116 {
11117 i32::try_from(v)
11118 .ok()
11119 .and_then(|x| x.try_into().ok())
11120 .ok_or_else(|| {
11121 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11122 })
11123 }
11124
11125 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11126 where
11127 E: serde::de::Error,
11128 {
11129 match value {
11130 "UNSPECIFIED" => Ok(table_schema_change::TableChangeType::Unspecified),
11131 "ALTER" => Ok(table_schema_change::TableChangeType::Alter),
11132 "CREATE" => Ok(table_schema_change::TableChangeType::Create),
11133 "DROP" => Ok(table_schema_change::TableChangeType::Drop),
11134 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11135 }
11136 }
11137 }
11138 deserializer.deserialize_any(GeneratedVisitor)
11139 }
11140}
11141impl serde::Serialize for WaitRequest {
11142 #[allow(deprecated)]
11143 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11144 where
11145 S: serde::Serializer,
11146 {
11147 use serde::ser::SerializeStruct;
11148 let len = 0;
11149 let struct_ser = serializer.serialize_struct("ddl_service.WaitRequest", len)?;
11150 struct_ser.end()
11151 }
11152}
11153impl<'de> serde::Deserialize<'de> for WaitRequest {
11154 #[allow(deprecated)]
11155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11156 where
11157 D: serde::Deserializer<'de>,
11158 {
11159 const FIELDS: &[&str] = &[
11160 ];
11161
11162 #[allow(clippy::enum_variant_names)]
11163 enum GeneratedField {
11164 }
11165 impl<'de> serde::Deserialize<'de> for GeneratedField {
11166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11167 where
11168 D: serde::Deserializer<'de>,
11169 {
11170 struct GeneratedVisitor;
11171
11172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11173 type Value = GeneratedField;
11174
11175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11176 write!(formatter, "expected one of: {:?}", &FIELDS)
11177 }
11178
11179 #[allow(unused_variables)]
11180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11181 where
11182 E: serde::de::Error,
11183 {
11184 Err(serde::de::Error::unknown_field(value, FIELDS))
11185 }
11186 }
11187 deserializer.deserialize_identifier(GeneratedVisitor)
11188 }
11189 }
11190 struct GeneratedVisitor;
11191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11192 type Value = WaitRequest;
11193
11194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11195 formatter.write_str("struct ddl_service.WaitRequest")
11196 }
11197
11198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitRequest, V::Error>
11199 where
11200 V: serde::de::MapAccess<'de>,
11201 {
11202 while map_.next_key::<GeneratedField>()?.is_some() {
11203 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11204 }
11205 Ok(WaitRequest {
11206 })
11207 }
11208 }
11209 deserializer.deserialize_struct("ddl_service.WaitRequest", FIELDS, GeneratedVisitor)
11210 }
11211}
11212impl serde::Serialize for WaitResponse {
11213 #[allow(deprecated)]
11214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11215 where
11216 S: serde::Serializer,
11217 {
11218 use serde::ser::SerializeStruct;
11219 let len = 0;
11220 let struct_ser = serializer.serialize_struct("ddl_service.WaitResponse", len)?;
11221 struct_ser.end()
11222 }
11223}
11224impl<'de> serde::Deserialize<'de> for WaitResponse {
11225 #[allow(deprecated)]
11226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11227 where
11228 D: serde::Deserializer<'de>,
11229 {
11230 const FIELDS: &[&str] = &[
11231 ];
11232
11233 #[allow(clippy::enum_variant_names)]
11234 enum GeneratedField {
11235 }
11236 impl<'de> serde::Deserialize<'de> for GeneratedField {
11237 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11238 where
11239 D: serde::Deserializer<'de>,
11240 {
11241 struct GeneratedVisitor;
11242
11243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11244 type Value = GeneratedField;
11245
11246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11247 write!(formatter, "expected one of: {:?}", &FIELDS)
11248 }
11249
11250 #[allow(unused_variables)]
11251 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11252 where
11253 E: serde::de::Error,
11254 {
11255 Err(serde::de::Error::unknown_field(value, FIELDS))
11256 }
11257 }
11258 deserializer.deserialize_identifier(GeneratedVisitor)
11259 }
11260 }
11261 struct GeneratedVisitor;
11262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11263 type Value = WaitResponse;
11264
11265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11266 formatter.write_str("struct ddl_service.WaitResponse")
11267 }
11268
11269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitResponse, V::Error>
11270 where
11271 V: serde::de::MapAccess<'de>,
11272 {
11273 while map_.next_key::<GeneratedField>()?.is_some() {
11274 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11275 }
11276 Ok(WaitResponse {
11277 })
11278 }
11279 }
11280 deserializer.deserialize_struct("ddl_service.WaitResponse", FIELDS, GeneratedVisitor)
11281 }
11282}
11283impl serde::Serialize for WaitVersion {
11284 #[allow(deprecated)]
11285 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11286 where
11287 S: serde::Serializer,
11288 {
11289 use serde::ser::SerializeStruct;
11290 let mut len = 0;
11291 if self.catalog_version != 0 {
11292 len += 1;
11293 }
11294 if self.hummock_version_id != 0 {
11295 len += 1;
11296 }
11297 let mut struct_ser = serializer.serialize_struct("ddl_service.WaitVersion", len)?;
11298 if self.catalog_version != 0 {
11299 #[allow(clippy::needless_borrow)]
11300 #[allow(clippy::needless_borrows_for_generic_args)]
11301 struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11302 }
11303 if self.hummock_version_id != 0 {
11304 #[allow(clippy::needless_borrow)]
11305 #[allow(clippy::needless_borrows_for_generic_args)]
11306 struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
11307 }
11308 struct_ser.end()
11309 }
11310}
11311impl<'de> serde::Deserialize<'de> for WaitVersion {
11312 #[allow(deprecated)]
11313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11314 where
11315 D: serde::Deserializer<'de>,
11316 {
11317 const FIELDS: &[&str] = &[
11318 "catalog_version",
11319 "catalogVersion",
11320 "hummock_version_id",
11321 "hummockVersionId",
11322 ];
11323
11324 #[allow(clippy::enum_variant_names)]
11325 enum GeneratedField {
11326 CatalogVersion,
11327 HummockVersionId,
11328 }
11329 impl<'de> serde::Deserialize<'de> for GeneratedField {
11330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11331 where
11332 D: serde::Deserializer<'de>,
11333 {
11334 struct GeneratedVisitor;
11335
11336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11337 type Value = GeneratedField;
11338
11339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11340 write!(formatter, "expected one of: {:?}", &FIELDS)
11341 }
11342
11343 #[allow(unused_variables)]
11344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11345 where
11346 E: serde::de::Error,
11347 {
11348 match value {
11349 "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
11350 "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
11351 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11352 }
11353 }
11354 }
11355 deserializer.deserialize_identifier(GeneratedVisitor)
11356 }
11357 }
11358 struct GeneratedVisitor;
11359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11360 type Value = WaitVersion;
11361
11362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11363 formatter.write_str("struct ddl_service.WaitVersion")
11364 }
11365
11366 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WaitVersion, V::Error>
11367 where
11368 V: serde::de::MapAccess<'de>,
11369 {
11370 let mut catalog_version__ = None;
11371 let mut hummock_version_id__ = None;
11372 while let Some(k) = map_.next_key()? {
11373 match k {
11374 GeneratedField::CatalogVersion => {
11375 if catalog_version__.is_some() {
11376 return Err(serde::de::Error::duplicate_field("catalogVersion"));
11377 }
11378 catalog_version__ =
11379 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11380 ;
11381 }
11382 GeneratedField::HummockVersionId => {
11383 if hummock_version_id__.is_some() {
11384 return Err(serde::de::Error::duplicate_field("hummockVersionId"));
11385 }
11386 hummock_version_id__ =
11387 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11388 ;
11389 }
11390 }
11391 }
11392 Ok(WaitVersion {
11393 catalog_version: catalog_version__.unwrap_or_default(),
11394 hummock_version_id: hummock_version_id__.unwrap_or_default(),
11395 })
11396 }
11397 }
11398 deserializer.deserialize_struct("ddl_service.WaitVersion", FIELDS, GeneratedVisitor)
11399 }
11400}