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