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