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