1#![allow(clippy::redundant_closure)]
7
8
9pub type IdType = ::std::primitive::i64;
10
11pub type Timestamp = ::std::primitive::i64;
12
13pub type Year = ::std::primitive::i16;
14
15#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
16pub struct YearMonth {
17 pub year: ::std::primitive::i16,
18 pub month: ::std::primitive::i8,
19 #[doc(hidden)]
24 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
25}
26
27#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
28pub struct Date {
29 pub year: ::std::primitive::i16,
30 pub month: ::std::primitive::i8,
31 pub day: ::std::primitive::i8,
32 #[doc(hidden)]
37 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
38}
39
40#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
41pub struct DateTime {
42 pub year: ::std::primitive::i16,
43 pub month: ::std::primitive::i8,
44 pub day: ::std::primitive::i8,
45 pub hour: ::std::primitive::i8,
46 pub minute: ::std::primitive::i8,
47 pub second: ::std::primitive::i8,
48 pub millisec: ::std::primitive::i16,
49 pub microsec: ::std::primitive::i16,
50 #[doc(hidden)]
55 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
56}
57
58#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
59pub struct Vertex {
60 pub id: common::types::VertexID,
61 #[doc(hidden)]
66 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
67}
68
69#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
70pub struct Edge {
71 pub r#type: ::std::vec::Vec<::std::primitive::u8>,
72 pub ranking: common::types::EdgeRanking,
73 pub src: ::std::option::Option<common::types::VertexID>,
74 pub dst: ::std::option::Option<common::types::VertexID>,
75 #[doc(hidden)]
80 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
81}
82
83#[derive(Clone, PartialEq, Debug)]
84pub enum PathEntry {
85 vertex(crate::types::Vertex),
86 edge(crate::types::Edge),
87 UnknownField(::std::primitive::i32),
88}
89
90#[derive(Clone, PartialEq)]
91pub struct Path {
92 pub entry_list: ::std::vec::Vec<crate::types::PathEntry>,
93 #[doc(hidden)]
98 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
99}
100
101#[derive(Clone, PartialEq, Debug)]
102pub enum ColumnValue {
103 bool_val(::std::primitive::bool),
104 integer(::std::primitive::i64),
105 id(crate::types::IdType),
106 single_precision(::std::primitive::f32),
107 double_precision(::std::primitive::f64),
108 str(::std::vec::Vec<::std::primitive::u8>),
109 timestamp(crate::types::Timestamp),
110 year(crate::types::Year),
111 month(crate::types::YearMonth),
112 date(crate::types::Date),
113 datetime(crate::types::DateTime),
114 path(crate::types::Path),
115 UnknownField(::std::primitive::i32),
116}
117
118#[derive(Clone, PartialEq)]
119pub struct RowValue {
120 pub columns: ::std::vec::Vec<crate::types::ColumnValue>,
121 #[doc(hidden)]
126 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
127}
128
129#[derive(Clone, PartialEq)]
130pub struct ExecutionResponse {
131 pub error_code: crate::types::ErrorCode,
132 pub latency_in_us: ::std::primitive::i32,
133 pub error_msg: ::std::option::Option<::std::string::String>,
134 pub column_names: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::primitive::u8>>>,
135 pub rows: ::std::option::Option<::std::vec::Vec<crate::types::RowValue>>,
136 pub space_name: ::std::option::Option<::std::string::String>,
137 pub warning_msg: ::std::option::Option<::std::string::String>,
138 #[doc(hidden)]
143 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
144}
145
146#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
147pub struct AuthResponse {
148 pub error_code: crate::types::ErrorCode,
149 pub session_id: ::std::option::Option<::std::primitive::i64>,
150 pub error_msg: ::std::option::Option<::std::string::String>,
151 #[doc(hidden)]
156 pub _dot_dot_Default_default: self::dot_dot::OtherFields,
157}
158
159#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
160pub struct ErrorCode(pub ::std::primitive::i32);
161
162impl ErrorCode {
163 pub const SUCCEEDED: Self = ErrorCode(0i32);
164 pub const E_DISCONNECTED: Self = ErrorCode(-1i32);
165 pub const E_FAIL_TO_CONNECT: Self = ErrorCode(-2i32);
166 pub const E_RPC_FAILURE: Self = ErrorCode(-3i32);
167 pub const E_BAD_USERNAME_PASSWORD: Self = ErrorCode(-4i32);
168 pub const E_SESSION_INVALID: Self = ErrorCode(-5i32);
169 pub const E_SESSION_TIMEOUT: Self = ErrorCode(-6i32);
170 pub const E_SYNTAX_ERROR: Self = ErrorCode(-7i32);
171 pub const E_EXECUTION_ERROR: Self = ErrorCode(-8i32);
172 pub const E_STATEMENT_EMTPY: Self = ErrorCode(-9i32);
173 pub const E_USER_NOT_FOUND: Self = ErrorCode(-10i32);
174 pub const E_BAD_PERMISSION: Self = ErrorCode(-11i32);
175}
176
177impl ::fbthrift::ThriftEnum for ErrorCode {
178 fn enumerate() -> &'static [(Self, &'static str)] {
179 &[
180 (Self::SUCCEEDED, "SUCCEEDED"),
181 (Self::E_DISCONNECTED, "E_DISCONNECTED"),
182 (Self::E_FAIL_TO_CONNECT, "E_FAIL_TO_CONNECT"),
183 (Self::E_RPC_FAILURE, "E_RPC_FAILURE"),
184 (Self::E_BAD_USERNAME_PASSWORD, "E_BAD_USERNAME_PASSWORD"),
185 (Self::E_SESSION_INVALID, "E_SESSION_INVALID"),
186 (Self::E_SESSION_TIMEOUT, "E_SESSION_TIMEOUT"),
187 (Self::E_SYNTAX_ERROR, "E_SYNTAX_ERROR"),
188 (Self::E_EXECUTION_ERROR, "E_EXECUTION_ERROR"),
189 (Self::E_STATEMENT_EMTPY, "E_STATEMENT_EMTPY"),
190 (Self::E_USER_NOT_FOUND, "E_USER_NOT_FOUND"),
191 (Self::E_BAD_PERMISSION, "E_BAD_PERMISSION"),
192 ]
193 }
194
195 fn variants() -> &'static [&'static str] {
196 &[
197 "SUCCEEDED",
198 "E_DISCONNECTED",
199 "E_FAIL_TO_CONNECT",
200 "E_RPC_FAILURE",
201 "E_BAD_USERNAME_PASSWORD",
202 "E_SESSION_INVALID",
203 "E_SESSION_TIMEOUT",
204 "E_SYNTAX_ERROR",
205 "E_EXECUTION_ERROR",
206 "E_STATEMENT_EMTPY",
207 "E_USER_NOT_FOUND",
208 "E_BAD_PERMISSION",
209 ]
210 }
211
212 fn variant_values() -> &'static [Self] {
213 &[
214 Self::SUCCEEDED,
215 Self::E_DISCONNECTED,
216 Self::E_FAIL_TO_CONNECT,
217 Self::E_RPC_FAILURE,
218 Self::E_BAD_USERNAME_PASSWORD,
219 Self::E_SESSION_INVALID,
220 Self::E_SESSION_TIMEOUT,
221 Self::E_SYNTAX_ERROR,
222 Self::E_EXECUTION_ERROR,
223 Self::E_STATEMENT_EMTPY,
224 Self::E_USER_NOT_FOUND,
225 Self::E_BAD_PERMISSION,
226 ]
227 }
228}
229
230impl ::std::default::Default for ErrorCode {
231 fn default() -> Self {
232 Self(::fbthrift::__UNKNOWN_ID)
233 }
234}
235
236impl<'a> ::std::convert::From<&'a ErrorCode> for ::std::primitive::i32 {
237 #[inline]
238 fn from(x: &'a ErrorCode) -> Self {
239 x.0
240 }
241}
242
243impl ::std::convert::From<ErrorCode> for ::std::primitive::i32 {
244 #[inline]
245 fn from(x: ErrorCode) -> Self {
246 x.0
247 }
248}
249
250impl ::std::convert::From<::std::primitive::i32> for ErrorCode {
251 #[inline]
252 fn from(x: ::std::primitive::i32) -> Self {
253 Self(x)
254 }
255}
256
257impl ::std::fmt::Display for ErrorCode {
258 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
259 static VARIANTS_BY_NUMBER: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
260 ("E_BAD_PERMISSION", -11),
261 ("E_USER_NOT_FOUND", -10),
262 ("E_STATEMENT_EMTPY", -9),
263 ("E_EXECUTION_ERROR", -8),
264 ("E_SYNTAX_ERROR", -7),
265 ("E_SESSION_TIMEOUT", -6),
266 ("E_SESSION_INVALID", -5),
267 ("E_BAD_USERNAME_PASSWORD", -4),
268 ("E_RPC_FAILURE", -3),
269 ("E_FAIL_TO_CONNECT", -2),
270 ("E_DISCONNECTED", -1),
271 ("SUCCEEDED", 0),
272 ];
273 ::fbthrift::help::enum_display(VARIANTS_BY_NUMBER, fmt, self.0)
274 }
275}
276
277impl ::std::fmt::Debug for ErrorCode {
278 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
279 write!(fmt, "ErrorCode::{}", self)
280 }
281}
282
283impl ::std::str::FromStr for ErrorCode {
284 type Err = ::anyhow::Error;
285
286 fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
287 static VARIANTS_BY_NAME: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
288 ("E_BAD_PERMISSION", -11),
289 ("E_BAD_USERNAME_PASSWORD", -4),
290 ("E_DISCONNECTED", -1),
291 ("E_EXECUTION_ERROR", -8),
292 ("E_FAIL_TO_CONNECT", -2),
293 ("E_RPC_FAILURE", -3),
294 ("E_SESSION_INVALID", -5),
295 ("E_SESSION_TIMEOUT", -6),
296 ("E_STATEMENT_EMTPY", -9),
297 ("E_SYNTAX_ERROR", -7),
298 ("E_USER_NOT_FOUND", -10),
299 ("SUCCEEDED", 0),
300 ];
301 ::fbthrift::help::enum_from_str(VARIANTS_BY_NAME, string, "ErrorCode").map(Self)
302 }
303}
304
305impl ::fbthrift::GetTType for ErrorCode {
306 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
307}
308
309impl<P> ::fbthrift::Serialize<P> for ErrorCode
310where
311 P: ::fbthrift::ProtocolWriter,
312{
313 #[inline]
314 fn write(&self, p: &mut P) {
315 p.write_i32(self.into())
316 }
317}
318
319impl<P> ::fbthrift::Deserialize<P> for ErrorCode
320where
321 P: ::fbthrift::ProtocolReader,
322{
323 #[inline]
324 fn read(p: &mut P) -> ::anyhow::Result<Self> {
325 ::std::result::Result::Ok(Self::from(p.read_i32()?))
326 }
327}
328
329
330
331
332#[allow(clippy::derivable_impls)]
333impl ::std::default::Default for self::YearMonth {
334 fn default() -> Self {
335 Self {
336 year: ::std::default::Default::default(),
337 month: ::std::default::Default::default(),
338 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
339 }
340 }
341}
342
343impl ::std::fmt::Debug for self::YearMonth {
344 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
345 formatter
346 .debug_struct("YearMonth")
347 .field("year", &self.year)
348 .field("month", &self.month)
349 .finish()
350 }
351}
352
353unsafe impl ::std::marker::Send for self::YearMonth {}
354unsafe impl ::std::marker::Sync for self::YearMonth {}
355
356impl ::fbthrift::GetTType for self::YearMonth {
357 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
358}
359
360impl<P> ::fbthrift::Serialize<P> for self::YearMonth
361where
362 P: ::fbthrift::ProtocolWriter,
363{
364 fn write(&self, p: &mut P) {
365 p.write_struct_begin("YearMonth");
366 p.write_field_begin("year", ::fbthrift::TType::I16, 1);
367 ::fbthrift::Serialize::write(&self.year, p);
368 p.write_field_end();
369 p.write_field_begin("month", ::fbthrift::TType::Byte, 2);
370 ::fbthrift::Serialize::write(&self.month, p);
371 p.write_field_end();
372 p.write_field_stop();
373 p.write_struct_end();
374 }
375}
376
377impl<P> ::fbthrift::Deserialize<P> for self::YearMonth
378where
379 P: ::fbthrift::ProtocolReader,
380{
381 fn read(p: &mut P) -> ::anyhow::Result<Self> {
382 static FIELDS: &[::fbthrift::Field] = &[
383 ::fbthrift::Field::new("month", ::fbthrift::TType::Byte, 2),
384 ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 1),
385 ];
386 let mut field_year = ::std::option::Option::None;
387 let mut field_month = ::std::option::Option::None;
388 let _ = p.read_struct_begin(|_| ())?;
389 loop {
390 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
391 match (fty, fid as ::std::primitive::i32) {
392 (::fbthrift::TType::Stop, _) => break,
393 (::fbthrift::TType::I16, 1) => field_year = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
394 (::fbthrift::TType::Byte, 2) => field_month = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
395 (fty, _) => p.skip(fty)?,
396 }
397 p.read_field_end()?;
398 }
399 p.read_struct_end()?;
400 ::std::result::Result::Ok(Self {
401 year: field_year.unwrap_or_default(),
402 month: field_month.unwrap_or_default(),
403 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
404 })
405 }
406}
407
408
409#[allow(clippy::derivable_impls)]
410impl ::std::default::Default for self::Date {
411 fn default() -> Self {
412 Self {
413 year: ::std::default::Default::default(),
414 month: ::std::default::Default::default(),
415 day: ::std::default::Default::default(),
416 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
417 }
418 }
419}
420
421impl ::std::fmt::Debug for self::Date {
422 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
423 formatter
424 .debug_struct("Date")
425 .field("year", &self.year)
426 .field("month", &self.month)
427 .field("day", &self.day)
428 .finish()
429 }
430}
431
432unsafe impl ::std::marker::Send for self::Date {}
433unsafe impl ::std::marker::Sync for self::Date {}
434
435impl ::fbthrift::GetTType for self::Date {
436 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
437}
438
439impl<P> ::fbthrift::Serialize<P> for self::Date
440where
441 P: ::fbthrift::ProtocolWriter,
442{
443 fn write(&self, p: &mut P) {
444 p.write_struct_begin("Date");
445 p.write_field_begin("year", ::fbthrift::TType::I16, 1);
446 ::fbthrift::Serialize::write(&self.year, p);
447 p.write_field_end();
448 p.write_field_begin("month", ::fbthrift::TType::Byte, 2);
449 ::fbthrift::Serialize::write(&self.month, p);
450 p.write_field_end();
451 p.write_field_begin("day", ::fbthrift::TType::Byte, 3);
452 ::fbthrift::Serialize::write(&self.day, p);
453 p.write_field_end();
454 p.write_field_stop();
455 p.write_struct_end();
456 }
457}
458
459impl<P> ::fbthrift::Deserialize<P> for self::Date
460where
461 P: ::fbthrift::ProtocolReader,
462{
463 fn read(p: &mut P) -> ::anyhow::Result<Self> {
464 static FIELDS: &[::fbthrift::Field] = &[
465 ::fbthrift::Field::new("day", ::fbthrift::TType::Byte, 3),
466 ::fbthrift::Field::new("month", ::fbthrift::TType::Byte, 2),
467 ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 1),
468 ];
469 let mut field_year = ::std::option::Option::None;
470 let mut field_month = ::std::option::Option::None;
471 let mut field_day = ::std::option::Option::None;
472 let _ = p.read_struct_begin(|_| ())?;
473 loop {
474 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
475 match (fty, fid as ::std::primitive::i32) {
476 (::fbthrift::TType::Stop, _) => break,
477 (::fbthrift::TType::I16, 1) => field_year = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
478 (::fbthrift::TType::Byte, 2) => field_month = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
479 (::fbthrift::TType::Byte, 3) => field_day = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
480 (fty, _) => p.skip(fty)?,
481 }
482 p.read_field_end()?;
483 }
484 p.read_struct_end()?;
485 ::std::result::Result::Ok(Self {
486 year: field_year.unwrap_or_default(),
487 month: field_month.unwrap_or_default(),
488 day: field_day.unwrap_or_default(),
489 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
490 })
491 }
492}
493
494
495#[allow(clippy::derivable_impls)]
496impl ::std::default::Default for self::DateTime {
497 fn default() -> Self {
498 Self {
499 year: ::std::default::Default::default(),
500 month: ::std::default::Default::default(),
501 day: ::std::default::Default::default(),
502 hour: ::std::default::Default::default(),
503 minute: ::std::default::Default::default(),
504 second: ::std::default::Default::default(),
505 millisec: ::std::default::Default::default(),
506 microsec: ::std::default::Default::default(),
507 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
508 }
509 }
510}
511
512impl ::std::fmt::Debug for self::DateTime {
513 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
514 formatter
515 .debug_struct("DateTime")
516 .field("year", &self.year)
517 .field("month", &self.month)
518 .field("day", &self.day)
519 .field("hour", &self.hour)
520 .field("minute", &self.minute)
521 .field("second", &self.second)
522 .field("millisec", &self.millisec)
523 .field("microsec", &self.microsec)
524 .finish()
525 }
526}
527
528unsafe impl ::std::marker::Send for self::DateTime {}
529unsafe impl ::std::marker::Sync for self::DateTime {}
530
531impl ::fbthrift::GetTType for self::DateTime {
532 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
533}
534
535impl<P> ::fbthrift::Serialize<P> for self::DateTime
536where
537 P: ::fbthrift::ProtocolWriter,
538{
539 fn write(&self, p: &mut P) {
540 p.write_struct_begin("DateTime");
541 p.write_field_begin("year", ::fbthrift::TType::I16, 1);
542 ::fbthrift::Serialize::write(&self.year, p);
543 p.write_field_end();
544 p.write_field_begin("month", ::fbthrift::TType::Byte, 2);
545 ::fbthrift::Serialize::write(&self.month, p);
546 p.write_field_end();
547 p.write_field_begin("day", ::fbthrift::TType::Byte, 3);
548 ::fbthrift::Serialize::write(&self.day, p);
549 p.write_field_end();
550 p.write_field_begin("hour", ::fbthrift::TType::Byte, 4);
551 ::fbthrift::Serialize::write(&self.hour, p);
552 p.write_field_end();
553 p.write_field_begin("minute", ::fbthrift::TType::Byte, 5);
554 ::fbthrift::Serialize::write(&self.minute, p);
555 p.write_field_end();
556 p.write_field_begin("second", ::fbthrift::TType::Byte, 6);
557 ::fbthrift::Serialize::write(&self.second, p);
558 p.write_field_end();
559 p.write_field_begin("millisec", ::fbthrift::TType::I16, 7);
560 ::fbthrift::Serialize::write(&self.millisec, p);
561 p.write_field_end();
562 p.write_field_begin("microsec", ::fbthrift::TType::I16, 8);
563 ::fbthrift::Serialize::write(&self.microsec, p);
564 p.write_field_end();
565 p.write_field_stop();
566 p.write_struct_end();
567 }
568}
569
570impl<P> ::fbthrift::Deserialize<P> for self::DateTime
571where
572 P: ::fbthrift::ProtocolReader,
573{
574 fn read(p: &mut P) -> ::anyhow::Result<Self> {
575 static FIELDS: &[::fbthrift::Field] = &[
576 ::fbthrift::Field::new("day", ::fbthrift::TType::Byte, 3),
577 ::fbthrift::Field::new("hour", ::fbthrift::TType::Byte, 4),
578 ::fbthrift::Field::new("microsec", ::fbthrift::TType::I16, 8),
579 ::fbthrift::Field::new("millisec", ::fbthrift::TType::I16, 7),
580 ::fbthrift::Field::new("minute", ::fbthrift::TType::Byte, 5),
581 ::fbthrift::Field::new("month", ::fbthrift::TType::Byte, 2),
582 ::fbthrift::Field::new("second", ::fbthrift::TType::Byte, 6),
583 ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 1),
584 ];
585 let mut field_year = ::std::option::Option::None;
586 let mut field_month = ::std::option::Option::None;
587 let mut field_day = ::std::option::Option::None;
588 let mut field_hour = ::std::option::Option::None;
589 let mut field_minute = ::std::option::Option::None;
590 let mut field_second = ::std::option::Option::None;
591 let mut field_millisec = ::std::option::Option::None;
592 let mut field_microsec = ::std::option::Option::None;
593 let _ = p.read_struct_begin(|_| ())?;
594 loop {
595 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
596 match (fty, fid as ::std::primitive::i32) {
597 (::fbthrift::TType::Stop, _) => break,
598 (::fbthrift::TType::I16, 1) => field_year = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
599 (::fbthrift::TType::Byte, 2) => field_month = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
600 (::fbthrift::TType::Byte, 3) => field_day = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
601 (::fbthrift::TType::Byte, 4) => field_hour = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
602 (::fbthrift::TType::Byte, 5) => field_minute = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
603 (::fbthrift::TType::Byte, 6) => field_second = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
604 (::fbthrift::TType::I16, 7) => field_millisec = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
605 (::fbthrift::TType::I16, 8) => field_microsec = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
606 (fty, _) => p.skip(fty)?,
607 }
608 p.read_field_end()?;
609 }
610 p.read_struct_end()?;
611 ::std::result::Result::Ok(Self {
612 year: field_year.unwrap_or_default(),
613 month: field_month.unwrap_or_default(),
614 day: field_day.unwrap_or_default(),
615 hour: field_hour.unwrap_or_default(),
616 minute: field_minute.unwrap_or_default(),
617 second: field_second.unwrap_or_default(),
618 millisec: field_millisec.unwrap_or_default(),
619 microsec: field_microsec.unwrap_or_default(),
620 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
621 })
622 }
623}
624
625
626#[allow(clippy::derivable_impls)]
627impl ::std::default::Default for self::Vertex {
628 fn default() -> Self {
629 Self {
630 id: ::std::default::Default::default(),
631 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
632 }
633 }
634}
635
636impl ::std::fmt::Debug for self::Vertex {
637 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
638 formatter
639 .debug_struct("Vertex")
640 .field("id", &self.id)
641 .finish()
642 }
643}
644
645unsafe impl ::std::marker::Send for self::Vertex {}
646unsafe impl ::std::marker::Sync for self::Vertex {}
647
648impl ::fbthrift::GetTType for self::Vertex {
649 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
650}
651
652impl<P> ::fbthrift::Serialize<P> for self::Vertex
653where
654 P: ::fbthrift::ProtocolWriter,
655{
656 fn write(&self, p: &mut P) {
657 p.write_struct_begin("Vertex");
658 p.write_field_begin("id", ::fbthrift::TType::I64, 1);
659 ::fbthrift::Serialize::write(&self.id, p);
660 p.write_field_end();
661 p.write_field_stop();
662 p.write_struct_end();
663 }
664}
665
666impl<P> ::fbthrift::Deserialize<P> for self::Vertex
667where
668 P: ::fbthrift::ProtocolReader,
669{
670 fn read(p: &mut P) -> ::anyhow::Result<Self> {
671 static FIELDS: &[::fbthrift::Field] = &[
672 ::fbthrift::Field::new("id", ::fbthrift::TType::I64, 1),
673 ];
674 let mut field_id = ::std::option::Option::None;
675 let _ = p.read_struct_begin(|_| ())?;
676 loop {
677 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
678 match (fty, fid as ::std::primitive::i32) {
679 (::fbthrift::TType::Stop, _) => break,
680 (::fbthrift::TType::I64, 1) => field_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
681 (fty, _) => p.skip(fty)?,
682 }
683 p.read_field_end()?;
684 }
685 p.read_struct_end()?;
686 ::std::result::Result::Ok(Self {
687 id: field_id.unwrap_or_default(),
688 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
689 })
690 }
691}
692
693
694#[allow(clippy::derivable_impls)]
695impl ::std::default::Default for self::Edge {
696 fn default() -> Self {
697 Self {
698 r#type: ::std::default::Default::default(),
699 ranking: ::std::default::Default::default(),
700 src: ::std::option::Option::None,
701 dst: ::std::option::Option::None,
702 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
703 }
704 }
705}
706
707impl ::std::fmt::Debug for self::Edge {
708 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
709 formatter
710 .debug_struct("Edge")
711 .field("r#type", &self.r#type)
712 .field("ranking", &self.ranking)
713 .field("src", &self.src)
714 .field("dst", &self.dst)
715 .finish()
716 }
717}
718
719unsafe impl ::std::marker::Send for self::Edge {}
720unsafe impl ::std::marker::Sync for self::Edge {}
721
722impl ::fbthrift::GetTType for self::Edge {
723 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
724}
725
726impl<P> ::fbthrift::Serialize<P> for self::Edge
727where
728 P: ::fbthrift::ProtocolWriter,
729{
730 fn write(&self, p: &mut P) {
731 p.write_struct_begin("Edge");
732 p.write_field_begin("type", ::fbthrift::TType::String, 1);
733 ::fbthrift::Serialize::write(&self.r#type, p);
734 p.write_field_end();
735 p.write_field_begin("ranking", ::fbthrift::TType::I64, 2);
736 ::fbthrift::Serialize::write(&self.ranking, p);
737 p.write_field_end();
738 if let ::std::option::Option::Some(some) = &self.src {
739 p.write_field_begin("src", ::fbthrift::TType::I64, 3);
740 ::fbthrift::Serialize::write(some, p);
741 p.write_field_end();
742 }
743 if let ::std::option::Option::Some(some) = &self.dst {
744 p.write_field_begin("dst", ::fbthrift::TType::I64, 4);
745 ::fbthrift::Serialize::write(some, p);
746 p.write_field_end();
747 }
748 p.write_field_stop();
749 p.write_struct_end();
750 }
751}
752
753impl<P> ::fbthrift::Deserialize<P> for self::Edge
754where
755 P: ::fbthrift::ProtocolReader,
756{
757 fn read(p: &mut P) -> ::anyhow::Result<Self> {
758 static FIELDS: &[::fbthrift::Field] = &[
759 ::fbthrift::Field::new("dst", ::fbthrift::TType::I64, 4),
760 ::fbthrift::Field::new("ranking", ::fbthrift::TType::I64, 2),
761 ::fbthrift::Field::new("src", ::fbthrift::TType::I64, 3),
762 ::fbthrift::Field::new("type", ::fbthrift::TType::String, 1),
763 ];
764 let mut field_type = ::std::option::Option::None;
765 let mut field_ranking = ::std::option::Option::None;
766 let mut field_src = ::std::option::Option::None;
767 let mut field_dst = ::std::option::Option::None;
768 let _ = p.read_struct_begin(|_| ())?;
769 loop {
770 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
771 match (fty, fid as ::std::primitive::i32) {
772 (::fbthrift::TType::Stop, _) => break,
773 (::fbthrift::TType::String, 1) => field_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
774 (::fbthrift::TType::I64, 2) => field_ranking = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
775 (::fbthrift::TType::I64, 3) => field_src = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
776 (::fbthrift::TType::I64, 4) => field_dst = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
777 (fty, _) => p.skip(fty)?,
778 }
779 p.read_field_end()?;
780 }
781 p.read_struct_end()?;
782 ::std::result::Result::Ok(Self {
783 r#type: field_type.unwrap_or_default(),
784 ranking: field_ranking.unwrap_or_default(),
785 src: field_src,
786 dst: field_dst,
787 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
788 })
789 }
790}
791
792
793
794impl ::std::default::Default for PathEntry {
795 fn default() -> Self {
796 Self::UnknownField(-1)
797 }
798}
799
800impl ::fbthrift::GetTType for PathEntry {
801 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
802}
803
804impl<P> ::fbthrift::Serialize<P> for PathEntry
805where
806 P: ::fbthrift::ProtocolWriter,
807{
808 fn write(&self, p: &mut P) {
809 p.write_struct_begin("PathEntry");
810 match self {
811 Self::vertex(inner) => {
812 p.write_field_begin("vertex", ::fbthrift::TType::Struct, 1);
813 ::fbthrift::Serialize::write(inner, p);
814 p.write_field_end();
815 }
816 Self::edge(inner) => {
817 p.write_field_begin("edge", ::fbthrift::TType::Struct, 2);
818 ::fbthrift::Serialize::write(inner, p);
819 p.write_field_end();
820 }
821 Self::UnknownField(_) => {}
822 }
823 p.write_field_stop();
824 p.write_struct_end();
825 }
826}
827
828impl<P> ::fbthrift::Deserialize<P> for PathEntry
829where
830 P: ::fbthrift::ProtocolReader,
831{
832 fn read(p: &mut P) -> ::anyhow::Result<Self> {
833 static FIELDS: &[::fbthrift::Field] = &[
834 ::fbthrift::Field::new("edge", ::fbthrift::TType::Struct, 2),
835 ::fbthrift::Field::new("vertex", ::fbthrift::TType::Struct, 1),
836 ];
837 let _ = p.read_struct_begin(|_| ())?;
838 let mut once = false;
839 let mut alt = ::std::option::Option::None;
840 loop {
841 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
842 match (fty, fid as ::std::primitive::i32, once) {
843 (::fbthrift::TType::Stop, _, _) => break,
844 (::fbthrift::TType::Struct, 1, false) => {
845 once = true;
846 alt = ::std::option::Option::Some(Self::vertex(::fbthrift::Deserialize::read(p)?));
847 }
848 (::fbthrift::TType::Struct, 2, false) => {
849 once = true;
850 alt = ::std::option::Option::Some(Self::edge(::fbthrift::Deserialize::read(p)?));
851 }
852 (fty, _, false) => p.skip(fty)?,
853 (badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
854 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
855 format!(
856 "unwanted extra union {} field ty {:?} id {}",
857 "PathEntry",
858 badty,
859 badid,
860 ),
861 ))),
862 }
863 p.read_field_end()?;
864 }
865 p.read_struct_end()?;
866 ::std::result::Result::Ok(alt.unwrap_or_default())
867 }
868}
869
870#[allow(clippy::derivable_impls)]
871impl ::std::default::Default for self::Path {
872 fn default() -> Self {
873 Self {
874 entry_list: ::std::default::Default::default(),
875 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
876 }
877 }
878}
879
880impl ::std::fmt::Debug for self::Path {
881 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
882 formatter
883 .debug_struct("Path")
884 .field("entry_list", &self.entry_list)
885 .finish()
886 }
887}
888
889unsafe impl ::std::marker::Send for self::Path {}
890unsafe impl ::std::marker::Sync for self::Path {}
891
892impl ::fbthrift::GetTType for self::Path {
893 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
894}
895
896impl<P> ::fbthrift::Serialize<P> for self::Path
897where
898 P: ::fbthrift::ProtocolWriter,
899{
900 fn write(&self, p: &mut P) {
901 p.write_struct_begin("Path");
902 p.write_field_begin("entry_list", ::fbthrift::TType::List, 1);
903 ::fbthrift::Serialize::write(&self.entry_list, p);
904 p.write_field_end();
905 p.write_field_stop();
906 p.write_struct_end();
907 }
908}
909
910impl<P> ::fbthrift::Deserialize<P> for self::Path
911where
912 P: ::fbthrift::ProtocolReader,
913{
914 fn read(p: &mut P) -> ::anyhow::Result<Self> {
915 static FIELDS: &[::fbthrift::Field] = &[
916 ::fbthrift::Field::new("entry_list", ::fbthrift::TType::List, 1),
917 ];
918 let mut field_entry_list = ::std::option::Option::None;
919 let _ = p.read_struct_begin(|_| ())?;
920 loop {
921 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
922 match (fty, fid as ::std::primitive::i32) {
923 (::fbthrift::TType::Stop, _) => break,
924 (::fbthrift::TType::List, 1) => field_entry_list = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
925 (fty, _) => p.skip(fty)?,
926 }
927 p.read_field_end()?;
928 }
929 p.read_struct_end()?;
930 ::std::result::Result::Ok(Self {
931 entry_list: field_entry_list.unwrap_or_default(),
932 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
933 })
934 }
935}
936
937
938
939impl ::std::default::Default for ColumnValue {
940 fn default() -> Self {
941 Self::UnknownField(-1)
942 }
943}
944
945impl ::fbthrift::GetTType for ColumnValue {
946 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
947}
948
949impl<P> ::fbthrift::Serialize<P> for ColumnValue
950where
951 P: ::fbthrift::ProtocolWriter,
952{
953 fn write(&self, p: &mut P) {
954 p.write_struct_begin("ColumnValue");
955 match self {
956 Self::bool_val(inner) => {
957 p.write_field_begin("bool_val", ::fbthrift::TType::Bool, 1);
958 ::fbthrift::Serialize::write(inner, p);
959 p.write_field_end();
960 }
961 Self::integer(inner) => {
962 p.write_field_begin("integer", ::fbthrift::TType::I64, 2);
963 ::fbthrift::Serialize::write(inner, p);
964 p.write_field_end();
965 }
966 Self::id(inner) => {
967 p.write_field_begin("id", ::fbthrift::TType::I64, 3);
968 ::fbthrift::Serialize::write(inner, p);
969 p.write_field_end();
970 }
971 Self::single_precision(inner) => {
972 p.write_field_begin("single_precision", ::fbthrift::TType::Float, 4);
973 ::fbthrift::Serialize::write(inner, p);
974 p.write_field_end();
975 }
976 Self::double_precision(inner) => {
977 p.write_field_begin("double_precision", ::fbthrift::TType::Double, 5);
978 ::fbthrift::Serialize::write(inner, p);
979 p.write_field_end();
980 }
981 Self::str(inner) => {
982 p.write_field_begin("str", ::fbthrift::TType::String, 6);
983 ::fbthrift::Serialize::write(inner, p);
984 p.write_field_end();
985 }
986 Self::timestamp(inner) => {
987 p.write_field_begin("timestamp", ::fbthrift::TType::I64, 7);
988 ::fbthrift::Serialize::write(inner, p);
989 p.write_field_end();
990 }
991 Self::year(inner) => {
992 p.write_field_begin("year", ::fbthrift::TType::I16, 8);
993 ::fbthrift::Serialize::write(inner, p);
994 p.write_field_end();
995 }
996 Self::month(inner) => {
997 p.write_field_begin("month", ::fbthrift::TType::Struct, 9);
998 ::fbthrift::Serialize::write(inner, p);
999 p.write_field_end();
1000 }
1001 Self::date(inner) => {
1002 p.write_field_begin("date", ::fbthrift::TType::Struct, 10);
1003 ::fbthrift::Serialize::write(inner, p);
1004 p.write_field_end();
1005 }
1006 Self::datetime(inner) => {
1007 p.write_field_begin("datetime", ::fbthrift::TType::Struct, 11);
1008 ::fbthrift::Serialize::write(inner, p);
1009 p.write_field_end();
1010 }
1011 Self::path(inner) => {
1012 p.write_field_begin("path", ::fbthrift::TType::Struct, 41);
1013 ::fbthrift::Serialize::write(inner, p);
1014 p.write_field_end();
1015 }
1016 Self::UnknownField(_) => {}
1017 }
1018 p.write_field_stop();
1019 p.write_struct_end();
1020 }
1021}
1022
1023impl<P> ::fbthrift::Deserialize<P> for ColumnValue
1024where
1025 P: ::fbthrift::ProtocolReader,
1026{
1027 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1028 static FIELDS: &[::fbthrift::Field] = &[
1029 ::fbthrift::Field::new("bool_val", ::fbthrift::TType::Bool, 1),
1030 ::fbthrift::Field::new("date", ::fbthrift::TType::Struct, 10),
1031 ::fbthrift::Field::new("datetime", ::fbthrift::TType::Struct, 11),
1032 ::fbthrift::Field::new("double_precision", ::fbthrift::TType::Double, 5),
1033 ::fbthrift::Field::new("id", ::fbthrift::TType::I64, 3),
1034 ::fbthrift::Field::new("integer", ::fbthrift::TType::I64, 2),
1035 ::fbthrift::Field::new("month", ::fbthrift::TType::Struct, 9),
1036 ::fbthrift::Field::new("path", ::fbthrift::TType::Struct, 41),
1037 ::fbthrift::Field::new("single_precision", ::fbthrift::TType::Float, 4),
1038 ::fbthrift::Field::new("str", ::fbthrift::TType::String, 6),
1039 ::fbthrift::Field::new("timestamp", ::fbthrift::TType::I64, 7),
1040 ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 8),
1041 ];
1042 let _ = p.read_struct_begin(|_| ())?;
1043 let mut once = false;
1044 let mut alt = ::std::option::Option::None;
1045 loop {
1046 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
1047 match (fty, fid as ::std::primitive::i32, once) {
1048 (::fbthrift::TType::Stop, _, _) => break,
1049 (::fbthrift::TType::Bool, 1, false) => {
1050 once = true;
1051 alt = ::std::option::Option::Some(Self::bool_val(::fbthrift::Deserialize::read(p)?));
1052 }
1053 (::fbthrift::TType::I64, 2, false) => {
1054 once = true;
1055 alt = ::std::option::Option::Some(Self::integer(::fbthrift::Deserialize::read(p)?));
1056 }
1057 (::fbthrift::TType::I64, 3, false) => {
1058 once = true;
1059 alt = ::std::option::Option::Some(Self::id(::fbthrift::Deserialize::read(p)?));
1060 }
1061 (::fbthrift::TType::Float, 4, false) => {
1062 once = true;
1063 alt = ::std::option::Option::Some(Self::single_precision(::fbthrift::Deserialize::read(p)?));
1064 }
1065 (::fbthrift::TType::Double, 5, false) => {
1066 once = true;
1067 alt = ::std::option::Option::Some(Self::double_precision(::fbthrift::Deserialize::read(p)?));
1068 }
1069 (::fbthrift::TType::String, 6, false) => {
1070 once = true;
1071 alt = ::std::option::Option::Some(Self::str(::fbthrift::Deserialize::read(p)?));
1072 }
1073 (::fbthrift::TType::I64, 7, false) => {
1074 once = true;
1075 alt = ::std::option::Option::Some(Self::timestamp(::fbthrift::Deserialize::read(p)?));
1076 }
1077 (::fbthrift::TType::I16, 8, false) => {
1078 once = true;
1079 alt = ::std::option::Option::Some(Self::year(::fbthrift::Deserialize::read(p)?));
1080 }
1081 (::fbthrift::TType::Struct, 9, false) => {
1082 once = true;
1083 alt = ::std::option::Option::Some(Self::month(::fbthrift::Deserialize::read(p)?));
1084 }
1085 (::fbthrift::TType::Struct, 10, false) => {
1086 once = true;
1087 alt = ::std::option::Option::Some(Self::date(::fbthrift::Deserialize::read(p)?));
1088 }
1089 (::fbthrift::TType::Struct, 11, false) => {
1090 once = true;
1091 alt = ::std::option::Option::Some(Self::datetime(::fbthrift::Deserialize::read(p)?));
1092 }
1093 (::fbthrift::TType::Struct, 41, false) => {
1094 once = true;
1095 alt = ::std::option::Option::Some(Self::path(::fbthrift::Deserialize::read(p)?));
1096 }
1097 (fty, _, false) => p.skip(fty)?,
1098 (badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
1099 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1100 format!(
1101 "unwanted extra union {} field ty {:?} id {}",
1102 "ColumnValue",
1103 badty,
1104 badid,
1105 ),
1106 ))),
1107 }
1108 p.read_field_end()?;
1109 }
1110 p.read_struct_end()?;
1111 ::std::result::Result::Ok(alt.unwrap_or_default())
1112 }
1113}
1114
1115#[allow(clippy::derivable_impls)]
1116impl ::std::default::Default for self::RowValue {
1117 fn default() -> Self {
1118 Self {
1119 columns: ::std::default::Default::default(),
1120 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
1121 }
1122 }
1123}
1124
1125impl ::std::fmt::Debug for self::RowValue {
1126 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1127 formatter
1128 .debug_struct("RowValue")
1129 .field("columns", &self.columns)
1130 .finish()
1131 }
1132}
1133
1134unsafe impl ::std::marker::Send for self::RowValue {}
1135unsafe impl ::std::marker::Sync for self::RowValue {}
1136
1137impl ::fbthrift::GetTType for self::RowValue {
1138 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1139}
1140
1141impl<P> ::fbthrift::Serialize<P> for self::RowValue
1142where
1143 P: ::fbthrift::ProtocolWriter,
1144{
1145 fn write(&self, p: &mut P) {
1146 p.write_struct_begin("RowValue");
1147 p.write_field_begin("columns", ::fbthrift::TType::List, 1);
1148 ::fbthrift::Serialize::write(&self.columns, p);
1149 p.write_field_end();
1150 p.write_field_stop();
1151 p.write_struct_end();
1152 }
1153}
1154
1155impl<P> ::fbthrift::Deserialize<P> for self::RowValue
1156where
1157 P: ::fbthrift::ProtocolReader,
1158{
1159 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1160 static FIELDS: &[::fbthrift::Field] = &[
1161 ::fbthrift::Field::new("columns", ::fbthrift::TType::List, 1),
1162 ];
1163 let mut field_columns = ::std::option::Option::None;
1164 let _ = p.read_struct_begin(|_| ())?;
1165 loop {
1166 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
1167 match (fty, fid as ::std::primitive::i32) {
1168 (::fbthrift::TType::Stop, _) => break,
1169 (::fbthrift::TType::List, 1) => field_columns = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1170 (fty, _) => p.skip(fty)?,
1171 }
1172 p.read_field_end()?;
1173 }
1174 p.read_struct_end()?;
1175 ::std::result::Result::Ok(Self {
1176 columns: field_columns.unwrap_or_default(),
1177 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
1178 })
1179 }
1180}
1181
1182
1183#[allow(clippy::derivable_impls)]
1184impl ::std::default::Default for self::ExecutionResponse {
1185 fn default() -> Self {
1186 Self {
1187 error_code: ::std::default::Default::default(),
1188 latency_in_us: ::std::default::Default::default(),
1189 error_msg: ::std::option::Option::None,
1190 column_names: ::std::option::Option::None,
1191 rows: ::std::option::Option::None,
1192 space_name: ::std::option::Option::None,
1193 warning_msg: ::std::option::Option::None,
1194 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
1195 }
1196 }
1197}
1198
1199impl ::std::fmt::Debug for self::ExecutionResponse {
1200 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1201 formatter
1202 .debug_struct("ExecutionResponse")
1203 .field("error_code", &self.error_code)
1204 .field("latency_in_us", &self.latency_in_us)
1205 .field("error_msg", &self.error_msg)
1206 .field("column_names", &self.column_names)
1207 .field("rows", &self.rows)
1208 .field("space_name", &self.space_name)
1209 .field("warning_msg", &self.warning_msg)
1210 .finish()
1211 }
1212}
1213
1214unsafe impl ::std::marker::Send for self::ExecutionResponse {}
1215unsafe impl ::std::marker::Sync for self::ExecutionResponse {}
1216
1217impl ::fbthrift::GetTType for self::ExecutionResponse {
1218 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1219}
1220
1221impl<P> ::fbthrift::Serialize<P> for self::ExecutionResponse
1222where
1223 P: ::fbthrift::ProtocolWriter,
1224{
1225 fn write(&self, p: &mut P) {
1226 p.write_struct_begin("ExecutionResponse");
1227 p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
1228 ::fbthrift::Serialize::write(&self.error_code, p);
1229 p.write_field_end();
1230 p.write_field_begin("latency_in_us", ::fbthrift::TType::I32, 2);
1231 ::fbthrift::Serialize::write(&self.latency_in_us, p);
1232 p.write_field_end();
1233 if let ::std::option::Option::Some(some) = &self.error_msg {
1234 p.write_field_begin("error_msg", ::fbthrift::TType::String, 3);
1235 ::fbthrift::Serialize::write(some, p);
1236 p.write_field_end();
1237 }
1238 if let ::std::option::Option::Some(some) = &self.column_names {
1239 p.write_field_begin("column_names", ::fbthrift::TType::List, 4);
1240 ::fbthrift::Serialize::write(some, p);
1241 p.write_field_end();
1242 }
1243 if let ::std::option::Option::Some(some) = &self.rows {
1244 p.write_field_begin("rows", ::fbthrift::TType::List, 5);
1245 ::fbthrift::Serialize::write(some, p);
1246 p.write_field_end();
1247 }
1248 if let ::std::option::Option::Some(some) = &self.space_name {
1249 p.write_field_begin("space_name", ::fbthrift::TType::String, 6);
1250 ::fbthrift::Serialize::write(some, p);
1251 p.write_field_end();
1252 }
1253 if let ::std::option::Option::Some(some) = &self.warning_msg {
1254 p.write_field_begin("warning_msg", ::fbthrift::TType::String, 7);
1255 ::fbthrift::Serialize::write(some, p);
1256 p.write_field_end();
1257 }
1258 p.write_field_stop();
1259 p.write_struct_end();
1260 }
1261}
1262
1263impl<P> ::fbthrift::Deserialize<P> for self::ExecutionResponse
1264where
1265 P: ::fbthrift::ProtocolReader,
1266{
1267 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1268 static FIELDS: &[::fbthrift::Field] = &[
1269 ::fbthrift::Field::new("column_names", ::fbthrift::TType::List, 4),
1270 ::fbthrift::Field::new("error_code", ::fbthrift::TType::I32, 1),
1271 ::fbthrift::Field::new("error_msg", ::fbthrift::TType::String, 3),
1272 ::fbthrift::Field::new("latency_in_us", ::fbthrift::TType::I32, 2),
1273 ::fbthrift::Field::new("rows", ::fbthrift::TType::List, 5),
1274 ::fbthrift::Field::new("space_name", ::fbthrift::TType::String, 6),
1275 ::fbthrift::Field::new("warning_msg", ::fbthrift::TType::String, 7),
1276 ];
1277 let mut field_error_code = ::std::option::Option::None;
1278 let mut field_latency_in_us = ::std::option::Option::None;
1279 let mut field_error_msg = ::std::option::Option::None;
1280 let mut field_column_names = ::std::option::Option::None;
1281 let mut field_rows = ::std::option::Option::None;
1282 let mut field_space_name = ::std::option::Option::None;
1283 let mut field_warning_msg = ::std::option::Option::None;
1284 let _ = p.read_struct_begin(|_| ())?;
1285 loop {
1286 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
1287 match (fty, fid as ::std::primitive::i32) {
1288 (::fbthrift::TType::Stop, _) => break,
1289 (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1290 (::fbthrift::TType::I32, 2) => field_latency_in_us = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1291 (::fbthrift::TType::String, 3) => field_error_msg = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1292 (::fbthrift::TType::List, 4) => field_column_names = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1293 (::fbthrift::TType::List, 5) => field_rows = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1294 (::fbthrift::TType::String, 6) => field_space_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1295 (::fbthrift::TType::String, 7) => field_warning_msg = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1296 (fty, _) => p.skip(fty)?,
1297 }
1298 p.read_field_end()?;
1299 }
1300 p.read_struct_end()?;
1301 ::std::result::Result::Ok(Self {
1302 error_code: field_error_code.unwrap_or_default(),
1303 latency_in_us: field_latency_in_us.unwrap_or_default(),
1304 error_msg: field_error_msg,
1305 column_names: field_column_names,
1306 rows: field_rows,
1307 space_name: field_space_name,
1308 warning_msg: field_warning_msg,
1309 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
1310 })
1311 }
1312}
1313
1314
1315#[allow(clippy::derivable_impls)]
1316impl ::std::default::Default for self::AuthResponse {
1317 fn default() -> Self {
1318 Self {
1319 error_code: ::std::default::Default::default(),
1320 session_id: ::std::option::Option::None,
1321 error_msg: ::std::option::Option::None,
1322 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
1323 }
1324 }
1325}
1326
1327impl ::std::fmt::Debug for self::AuthResponse {
1328 fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1329 formatter
1330 .debug_struct("AuthResponse")
1331 .field("error_code", &self.error_code)
1332 .field("session_id", &self.session_id)
1333 .field("error_msg", &self.error_msg)
1334 .finish()
1335 }
1336}
1337
1338unsafe impl ::std::marker::Send for self::AuthResponse {}
1339unsafe impl ::std::marker::Sync for self::AuthResponse {}
1340
1341impl ::fbthrift::GetTType for self::AuthResponse {
1342 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1343}
1344
1345impl<P> ::fbthrift::Serialize<P> for self::AuthResponse
1346where
1347 P: ::fbthrift::ProtocolWriter,
1348{
1349 fn write(&self, p: &mut P) {
1350 p.write_struct_begin("AuthResponse");
1351 p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
1352 ::fbthrift::Serialize::write(&self.error_code, p);
1353 p.write_field_end();
1354 if let ::std::option::Option::Some(some) = &self.session_id {
1355 p.write_field_begin("session_id", ::fbthrift::TType::I64, 2);
1356 ::fbthrift::Serialize::write(some, p);
1357 p.write_field_end();
1358 }
1359 if let ::std::option::Option::Some(some) = &self.error_msg {
1360 p.write_field_begin("error_msg", ::fbthrift::TType::String, 3);
1361 ::fbthrift::Serialize::write(some, p);
1362 p.write_field_end();
1363 }
1364 p.write_field_stop();
1365 p.write_struct_end();
1366 }
1367}
1368
1369impl<P> ::fbthrift::Deserialize<P> for self::AuthResponse
1370where
1371 P: ::fbthrift::ProtocolReader,
1372{
1373 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1374 static FIELDS: &[::fbthrift::Field] = &[
1375 ::fbthrift::Field::new("error_code", ::fbthrift::TType::I32, 1),
1376 ::fbthrift::Field::new("error_msg", ::fbthrift::TType::String, 3),
1377 ::fbthrift::Field::new("session_id", ::fbthrift::TType::I64, 2),
1378 ];
1379 let mut field_error_code = ::std::option::Option::None;
1380 let mut field_session_id = ::std::option::Option::None;
1381 let mut field_error_msg = ::std::option::Option::None;
1382 let _ = p.read_struct_begin(|_| ())?;
1383 loop {
1384 let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
1385 match (fty, fid as ::std::primitive::i32) {
1386 (::fbthrift::TType::Stop, _) => break,
1387 (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1388 (::fbthrift::TType::I64, 2) => field_session_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1389 (::fbthrift::TType::String, 3) => field_error_msg = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1390 (fty, _) => p.skip(fty)?,
1391 }
1392 p.read_field_end()?;
1393 }
1394 p.read_struct_end()?;
1395 ::std::result::Result::Ok(Self {
1396 error_code: field_error_code.unwrap_or_default(),
1397 session_id: field_session_id,
1398 error_msg: field_error_msg,
1399 _dot_dot_Default_default: self::dot_dot::OtherFields(()),
1400 })
1401 }
1402}
1403
1404
1405mod dot_dot {
1406 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1407 pub struct OtherFields(pub(crate) ());
1408
1409 #[allow(dead_code)] pub(super) fn default_for_serde_deserialize() -> OtherFields {
1411 OtherFields(())
1412 }
1413}