nebula-fbthrift-graph-v1 0.3.0

// @generated by Thrift for src/interface/graph.thrift
// This file is probably not the place you want to edit!

//! Thrift type definitions for `graph`.

#![allow(clippy::redundant_closure)]


pub type IdType = ::std::primitive::i64;

pub type Timestamp = ::std::primitive::i64;

pub type Year = ::std::primitive::i16;

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct YearMonth {
    pub year: ::std::primitive::i16,
    pub month: ::std::primitive::i8,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Date {
    pub year: ::std::primitive::i16,
    pub month: ::std::primitive::i8,
    pub day: ::std::primitive::i8,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DateTime {
    pub year: ::std::primitive::i16,
    pub month: ::std::primitive::i8,
    pub day: ::std::primitive::i8,
    pub hour: ::std::primitive::i8,
    pub minute: ::std::primitive::i8,
    pub second: ::std::primitive::i8,
    pub millisec: ::std::primitive::i16,
    pub microsec: ::std::primitive::i16,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Vertex {
    pub id: common::types::VertexID,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Edge {
    pub r#type: ::std::vec::Vec<::std::primitive::u8>,
    pub ranking: common::types::EdgeRanking,
    pub src: ::std::option::Option<common::types::VertexID>,
    pub dst: ::std::option::Option<common::types::VertexID>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Debug)]
pub enum PathEntry {
    vertex(crate::types::Vertex),
    edge(crate::types::Edge),
    UnknownField(::std::primitive::i32),
}

#[derive(Clone, PartialEq)]
pub struct Path {
    pub entry_list: ::std::vec::Vec<crate::types::PathEntry>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Debug)]
pub enum ColumnValue {
    bool_val(::std::primitive::bool),
    integer(::std::primitive::i64),
    id(crate::types::IdType),
    single_precision(::std::primitive::f32),
    double_precision(::std::primitive::f64),
    str(::std::vec::Vec<::std::primitive::u8>),
    timestamp(crate::types::Timestamp),
    year(crate::types::Year),
    month(crate::types::YearMonth),
    date(crate::types::Date),
    datetime(crate::types::DateTime),
    path(crate::types::Path),
    UnknownField(::std::primitive::i32),
}

#[derive(Clone, PartialEq)]
pub struct RowValue {
    pub columns: ::std::vec::Vec<crate::types::ColumnValue>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq)]
pub struct ExecutionResponse {
    pub error_code: crate::types::ErrorCode,
    pub latency_in_us: ::std::primitive::i32,
    pub error_msg: ::std::option::Option<::std::string::String>,
    pub column_names: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::primitive::u8>>>,
    pub rows: ::std::option::Option<::std::vec::Vec<crate::types::RowValue>>,
    pub space_name: ::std::option::Option<::std::string::String>,
    pub warning_msg: ::std::option::Option<::std::string::String>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct AuthResponse {
    pub error_code: crate::types::ErrorCode,
    pub session_id: ::std::option::Option<::std::primitive::i64>,
    pub error_msg: ::std::option::Option<::std::string::String>,
    // This field forces `..Default::default()` when instantiating this
    // struct, to make code future-proof against new fields added later to
    // the definition in Thrift. If you don't want this, add the annotation
    // `(rust.exhaustive)` to the Thrift struct to eliminate this field.
    #[doc(hidden)]
    pub _dot_dot_Default_default: self::dot_dot::OtherFields,
}

#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ErrorCode(pub ::std::primitive::i32);

impl ErrorCode {
    pub const SUCCEEDED: Self = ErrorCode(0i32);
    pub const E_DISCONNECTED: Self = ErrorCode(-1i32);
    pub const E_FAIL_TO_CONNECT: Self = ErrorCode(-2i32);
    pub const E_RPC_FAILURE: Self = ErrorCode(-3i32);
    pub const E_BAD_USERNAME_PASSWORD: Self = ErrorCode(-4i32);
    pub const E_SESSION_INVALID: Self = ErrorCode(-5i32);
    pub const E_SESSION_TIMEOUT: Self = ErrorCode(-6i32);
    pub const E_SYNTAX_ERROR: Self = ErrorCode(-7i32);
    pub const E_EXECUTION_ERROR: Self = ErrorCode(-8i32);
    pub const E_STATEMENT_EMTPY: Self = ErrorCode(-9i32);
    pub const E_USER_NOT_FOUND: Self = ErrorCode(-10i32);
    pub const E_BAD_PERMISSION: Self = ErrorCode(-11i32);
}

impl ::fbthrift::ThriftEnum for ErrorCode {
    fn enumerate() -> &'static [(Self, &'static str)] {
        &[
            (Self::SUCCEEDED, "SUCCEEDED"),
            (Self::E_DISCONNECTED, "E_DISCONNECTED"),
            (Self::E_FAIL_TO_CONNECT, "E_FAIL_TO_CONNECT"),
            (Self::E_RPC_FAILURE, "E_RPC_FAILURE"),
            (Self::E_BAD_USERNAME_PASSWORD, "E_BAD_USERNAME_PASSWORD"),
            (Self::E_SESSION_INVALID, "E_SESSION_INVALID"),
            (Self::E_SESSION_TIMEOUT, "E_SESSION_TIMEOUT"),
            (Self::E_SYNTAX_ERROR, "E_SYNTAX_ERROR"),
            (Self::E_EXECUTION_ERROR, "E_EXECUTION_ERROR"),
            (Self::E_STATEMENT_EMTPY, "E_STATEMENT_EMTPY"),
            (Self::E_USER_NOT_FOUND, "E_USER_NOT_FOUND"),
            (Self::E_BAD_PERMISSION, "E_BAD_PERMISSION"),
        ]
    }

    fn variants() -> &'static [&'static str] {
        &[
            "SUCCEEDED",
            "E_DISCONNECTED",
            "E_FAIL_TO_CONNECT",
            "E_RPC_FAILURE",
            "E_BAD_USERNAME_PASSWORD",
            "E_SESSION_INVALID",
            "E_SESSION_TIMEOUT",
            "E_SYNTAX_ERROR",
            "E_EXECUTION_ERROR",
            "E_STATEMENT_EMTPY",
            "E_USER_NOT_FOUND",
            "E_BAD_PERMISSION",
        ]
    }

    fn variant_values() -> &'static [Self] {
        &[
            Self::SUCCEEDED,
            Self::E_DISCONNECTED,
            Self::E_FAIL_TO_CONNECT,
            Self::E_RPC_FAILURE,
            Self::E_BAD_USERNAME_PASSWORD,
            Self::E_SESSION_INVALID,
            Self::E_SESSION_TIMEOUT,
            Self::E_SYNTAX_ERROR,
            Self::E_EXECUTION_ERROR,
            Self::E_STATEMENT_EMTPY,
            Self::E_USER_NOT_FOUND,
            Self::E_BAD_PERMISSION,
        ]
    }
}

impl ::std::default::Default for ErrorCode {
    fn default() -> Self {
        Self(::fbthrift::__UNKNOWN_ID)
    }
}

impl<'a> ::std::convert::From<&'a ErrorCode> for ::std::primitive::i32 {
    #[inline]
    fn from(x: &'a ErrorCode) -> Self {
        x.0
    }
}

impl ::std::convert::From<ErrorCode> for ::std::primitive::i32 {
    #[inline]
    fn from(x: ErrorCode) -> Self {
        x.0
    }
}

impl ::std::convert::From<::std::primitive::i32> for ErrorCode {
    #[inline]
    fn from(x: ::std::primitive::i32) -> Self {
        Self(x)
    }
}

impl ::std::fmt::Display for ErrorCode {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        static VARIANTS_BY_NUMBER: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
            ("E_BAD_PERMISSION", -11),
            ("E_USER_NOT_FOUND", -10),
            ("E_STATEMENT_EMTPY", -9),
            ("E_EXECUTION_ERROR", -8),
            ("E_SYNTAX_ERROR", -7),
            ("E_SESSION_TIMEOUT", -6),
            ("E_SESSION_INVALID", -5),
            ("E_BAD_USERNAME_PASSWORD", -4),
            ("E_RPC_FAILURE", -3),
            ("E_FAIL_TO_CONNECT", -2),
            ("E_DISCONNECTED", -1),
            ("SUCCEEDED", 0),
        ];
        ::fbthrift::help::enum_display(VARIANTS_BY_NUMBER, fmt, self.0)
    }
}

impl ::std::fmt::Debug for ErrorCode {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(fmt, "ErrorCode::{}", self)
    }
}

impl ::std::str::FromStr for ErrorCode {
    type Err = ::anyhow::Error;

    fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
        static VARIANTS_BY_NAME: &[(&::std::primitive::str, ::std::primitive::i32)] = &[
            ("E_BAD_PERMISSION", -11),
            ("E_BAD_USERNAME_PASSWORD", -4),
            ("E_DISCONNECTED", -1),
            ("E_EXECUTION_ERROR", -8),
            ("E_FAIL_TO_CONNECT", -2),
            ("E_RPC_FAILURE", -3),
            ("E_SESSION_INVALID", -5),
            ("E_SESSION_TIMEOUT", -6),
            ("E_STATEMENT_EMTPY", -9),
            ("E_SYNTAX_ERROR", -7),
            ("E_USER_NOT_FOUND", -10),
            ("SUCCEEDED", 0),
        ];
        ::fbthrift::help::enum_from_str(VARIANTS_BY_NAME, string, "ErrorCode").map(Self)
    }
}

impl ::fbthrift::GetTType for ErrorCode {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
}

impl<P> ::fbthrift::Serialize<P> for ErrorCode
where
    P: ::fbthrift::ProtocolWriter,
{
    #[inline]
    fn write(&self, p: &mut P) {
        p.write_i32(self.into())
    }
}

impl<P> ::fbthrift::Deserialize<P> for ErrorCode
where
    P: ::fbthrift::ProtocolReader,
{
    #[inline]
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        ::std::result::Result::Ok(Self::from(p.read_i32()?))
    }
}




#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::YearMonth {
    fn default() -> Self {
        Self {
            year: ::std::default::Default::default(),
            month: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::YearMonth {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("YearMonth")
            .field("year", &self.year)
            .field("month", &self.month)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::YearMonth {}
unsafe impl ::std::marker::Sync for self::YearMonth {}

impl ::fbthrift::GetTType for self::YearMonth {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::YearMonth
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("YearMonth");
        p.write_field_begin("year", ::fbthrift::TType::I16, 1);
        ::fbthrift::Serialize::write(&self.year, p);
        p.write_field_end();
        p.write_field_begin("month", ::fbthrift::TType::Byte, 2);
        ::fbthrift::Serialize::write(&self.month, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::YearMonth
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("month", ::fbthrift::TType::Byte, 2),
            ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 1),
        ];
        let mut field_year = ::std::option::Option::None;
        let mut field_month = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I16, 1) => field_year = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 2) => field_month = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            year: field_year.unwrap_or_default(),
            month: field_month.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::Date {
    fn default() -> Self {
        Self {
            year: ::std::default::Default::default(),
            month: ::std::default::Default::default(),
            day: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::Date {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("Date")
            .field("year", &self.year)
            .field("month", &self.month)
            .field("day", &self.day)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::Date {}
unsafe impl ::std::marker::Sync for self::Date {}

impl ::fbthrift::GetTType for self::Date {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::Date
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Date");
        p.write_field_begin("year", ::fbthrift::TType::I16, 1);
        ::fbthrift::Serialize::write(&self.year, p);
        p.write_field_end();
        p.write_field_begin("month", ::fbthrift::TType::Byte, 2);
        ::fbthrift::Serialize::write(&self.month, p);
        p.write_field_end();
        p.write_field_begin("day", ::fbthrift::TType::Byte, 3);
        ::fbthrift::Serialize::write(&self.day, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::Date
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("day", ::fbthrift::TType::Byte, 3),
            ::fbthrift::Field::new("month", ::fbthrift::TType::Byte, 2),
            ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 1),
        ];
        let mut field_year = ::std::option::Option::None;
        let mut field_month = ::std::option::Option::None;
        let mut field_day = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I16, 1) => field_year = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 2) => field_month = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 3) => field_day = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            year: field_year.unwrap_or_default(),
            month: field_month.unwrap_or_default(),
            day: field_day.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::DateTime {
    fn default() -> Self {
        Self {
            year: ::std::default::Default::default(),
            month: ::std::default::Default::default(),
            day: ::std::default::Default::default(),
            hour: ::std::default::Default::default(),
            minute: ::std::default::Default::default(),
            second: ::std::default::Default::default(),
            millisec: ::std::default::Default::default(),
            microsec: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::DateTime {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("DateTime")
            .field("year", &self.year)
            .field("month", &self.month)
            .field("day", &self.day)
            .field("hour", &self.hour)
            .field("minute", &self.minute)
            .field("second", &self.second)
            .field("millisec", &self.millisec)
            .field("microsec", &self.microsec)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::DateTime {}
unsafe impl ::std::marker::Sync for self::DateTime {}

impl ::fbthrift::GetTType for self::DateTime {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::DateTime
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("DateTime");
        p.write_field_begin("year", ::fbthrift::TType::I16, 1);
        ::fbthrift::Serialize::write(&self.year, p);
        p.write_field_end();
        p.write_field_begin("month", ::fbthrift::TType::Byte, 2);
        ::fbthrift::Serialize::write(&self.month, p);
        p.write_field_end();
        p.write_field_begin("day", ::fbthrift::TType::Byte, 3);
        ::fbthrift::Serialize::write(&self.day, p);
        p.write_field_end();
        p.write_field_begin("hour", ::fbthrift::TType::Byte, 4);
        ::fbthrift::Serialize::write(&self.hour, p);
        p.write_field_end();
        p.write_field_begin("minute", ::fbthrift::TType::Byte, 5);
        ::fbthrift::Serialize::write(&self.minute, p);
        p.write_field_end();
        p.write_field_begin("second", ::fbthrift::TType::Byte, 6);
        ::fbthrift::Serialize::write(&self.second, p);
        p.write_field_end();
        p.write_field_begin("millisec", ::fbthrift::TType::I16, 7);
        ::fbthrift::Serialize::write(&self.millisec, p);
        p.write_field_end();
        p.write_field_begin("microsec", ::fbthrift::TType::I16, 8);
        ::fbthrift::Serialize::write(&self.microsec, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::DateTime
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("day", ::fbthrift::TType::Byte, 3),
            ::fbthrift::Field::new("hour", ::fbthrift::TType::Byte, 4),
            ::fbthrift::Field::new("microsec", ::fbthrift::TType::I16, 8),
            ::fbthrift::Field::new("millisec", ::fbthrift::TType::I16, 7),
            ::fbthrift::Field::new("minute", ::fbthrift::TType::Byte, 5),
            ::fbthrift::Field::new("month", ::fbthrift::TType::Byte, 2),
            ::fbthrift::Field::new("second", ::fbthrift::TType::Byte, 6),
            ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 1),
        ];
        let mut field_year = ::std::option::Option::None;
        let mut field_month = ::std::option::Option::None;
        let mut field_day = ::std::option::Option::None;
        let mut field_hour = ::std::option::Option::None;
        let mut field_minute = ::std::option::Option::None;
        let mut field_second = ::std::option::Option::None;
        let mut field_millisec = ::std::option::Option::None;
        let mut field_microsec = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I16, 1) => field_year = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 2) => field_month = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 3) => field_day = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 4) => field_hour = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 5) => field_minute = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::Byte, 6) => field_second = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I16, 7) => field_millisec = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I16, 8) => field_microsec = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            year: field_year.unwrap_or_default(),
            month: field_month.unwrap_or_default(),
            day: field_day.unwrap_or_default(),
            hour: field_hour.unwrap_or_default(),
            minute: field_minute.unwrap_or_default(),
            second: field_second.unwrap_or_default(),
            millisec: field_millisec.unwrap_or_default(),
            microsec: field_microsec.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::Vertex {
    fn default() -> Self {
        Self {
            id: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::Vertex {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("Vertex")
            .field("id", &self.id)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::Vertex {}
unsafe impl ::std::marker::Sync for self::Vertex {}

impl ::fbthrift::GetTType for self::Vertex {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::Vertex
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Vertex");
        p.write_field_begin("id", ::fbthrift::TType::I64, 1);
        ::fbthrift::Serialize::write(&self.id, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::Vertex
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("id", ::fbthrift::TType::I64, 1),
        ];
        let mut field_id = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I64, 1) => field_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            id: field_id.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::Edge {
    fn default() -> Self {
        Self {
            r#type: ::std::default::Default::default(),
            ranking: ::std::default::Default::default(),
            src: ::std::option::Option::None,
            dst: ::std::option::Option::None,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::Edge {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("Edge")
            .field("r#type", &self.r#type)
            .field("ranking", &self.ranking)
            .field("src", &self.src)
            .field("dst", &self.dst)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::Edge {}
unsafe impl ::std::marker::Sync for self::Edge {}

impl ::fbthrift::GetTType for self::Edge {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::Edge
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Edge");
        p.write_field_begin("type", ::fbthrift::TType::String, 1);
        ::fbthrift::Serialize::write(&self.r#type, p);
        p.write_field_end();
        p.write_field_begin("ranking", ::fbthrift::TType::I64, 2);
        ::fbthrift::Serialize::write(&self.ranking, p);
        p.write_field_end();
        if let ::std::option::Option::Some(some) = &self.src {
            p.write_field_begin("src", ::fbthrift::TType::I64, 3);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.dst {
            p.write_field_begin("dst", ::fbthrift::TType::I64, 4);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::Edge
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("dst", ::fbthrift::TType::I64, 4),
            ::fbthrift::Field::new("ranking", ::fbthrift::TType::I64, 2),
            ::fbthrift::Field::new("src", ::fbthrift::TType::I64, 3),
            ::fbthrift::Field::new("type", ::fbthrift::TType::String, 1),
        ];
        let mut field_type = ::std::option::Option::None;
        let mut field_ranking = ::std::option::Option::None;
        let mut field_src = ::std::option::Option::None;
        let mut field_dst = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::String, 1) => field_type = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I64, 2) => field_ranking = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I64, 3) => field_src = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I64, 4) => field_dst = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            r#type: field_type.unwrap_or_default(),
            ranking: field_ranking.unwrap_or_default(),
            src: field_src,
            dst: field_dst,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}



impl ::std::default::Default for PathEntry {
    fn default() -> Self {
        Self::UnknownField(-1)
    }
}

impl ::fbthrift::GetTType for PathEntry {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for PathEntry
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("PathEntry");
        match self {
            Self::vertex(inner) => {
                p.write_field_begin("vertex", ::fbthrift::TType::Struct, 1);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::edge(inner) => {
                p.write_field_begin("edge", ::fbthrift::TType::Struct, 2);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::UnknownField(_) => {}
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for PathEntry
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("edge", ::fbthrift::TType::Struct, 2),
            ::fbthrift::Field::new("vertex", ::fbthrift::TType::Struct, 1),
        ];
        let _ = p.read_struct_begin(|_| ())?;
        let mut once = false;
        let mut alt = ::std::option::Option::None;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32, once) {
                (::fbthrift::TType::Stop, _, _) => break,
                (::fbthrift::TType::Struct, 1, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::vertex(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Struct, 2, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::edge(::fbthrift::Deserialize::read(p)?));
                }
                (fty, _, false) => p.skip(fty)?,
                (badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
                    ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
                    format!(
                        "unwanted extra union {} field ty {:?} id {}",
                        "PathEntry",
                        badty,
                        badid,
                    ),
                ))),
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(alt.unwrap_or_default())
    }
}

#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::Path {
    fn default() -> Self {
        Self {
            entry_list: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::Path {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("Path")
            .field("entry_list", &self.entry_list)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::Path {}
unsafe impl ::std::marker::Sync for self::Path {}

impl ::fbthrift::GetTType for self::Path {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::Path
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("Path");
        p.write_field_begin("entry_list", ::fbthrift::TType::List, 1);
        ::fbthrift::Serialize::write(&self.entry_list, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::Path
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("entry_list", ::fbthrift::TType::List, 1),
        ];
        let mut field_entry_list = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::List, 1) => field_entry_list = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            entry_list: field_entry_list.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}



impl ::std::default::Default for ColumnValue {
    fn default() -> Self {
        Self::UnknownField(-1)
    }
}

impl ::fbthrift::GetTType for ColumnValue {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for ColumnValue
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("ColumnValue");
        match self {
            Self::bool_val(inner) => {
                p.write_field_begin("bool_val", ::fbthrift::TType::Bool, 1);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::integer(inner) => {
                p.write_field_begin("integer", ::fbthrift::TType::I64, 2);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::id(inner) => {
                p.write_field_begin("id", ::fbthrift::TType::I64, 3);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::single_precision(inner) => {
                p.write_field_begin("single_precision", ::fbthrift::TType::Float, 4);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::double_precision(inner) => {
                p.write_field_begin("double_precision", ::fbthrift::TType::Double, 5);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::str(inner) => {
                p.write_field_begin("str", ::fbthrift::TType::String, 6);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::timestamp(inner) => {
                p.write_field_begin("timestamp", ::fbthrift::TType::I64, 7);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::year(inner) => {
                p.write_field_begin("year", ::fbthrift::TType::I16, 8);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::month(inner) => {
                p.write_field_begin("month", ::fbthrift::TType::Struct, 9);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::date(inner) => {
                p.write_field_begin("date", ::fbthrift::TType::Struct, 10);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::datetime(inner) => {
                p.write_field_begin("datetime", ::fbthrift::TType::Struct, 11);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::path(inner) => {
                p.write_field_begin("path", ::fbthrift::TType::Struct, 41);
                ::fbthrift::Serialize::write(inner, p);
                p.write_field_end();
            }
            Self::UnknownField(_) => {}
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for ColumnValue
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("bool_val", ::fbthrift::TType::Bool, 1),
            ::fbthrift::Field::new("date", ::fbthrift::TType::Struct, 10),
            ::fbthrift::Field::new("datetime", ::fbthrift::TType::Struct, 11),
            ::fbthrift::Field::new("double_precision", ::fbthrift::TType::Double, 5),
            ::fbthrift::Field::new("id", ::fbthrift::TType::I64, 3),
            ::fbthrift::Field::new("integer", ::fbthrift::TType::I64, 2),
            ::fbthrift::Field::new("month", ::fbthrift::TType::Struct, 9),
            ::fbthrift::Field::new("path", ::fbthrift::TType::Struct, 41),
            ::fbthrift::Field::new("single_precision", ::fbthrift::TType::Float, 4),
            ::fbthrift::Field::new("str", ::fbthrift::TType::String, 6),
            ::fbthrift::Field::new("timestamp", ::fbthrift::TType::I64, 7),
            ::fbthrift::Field::new("year", ::fbthrift::TType::I16, 8),
        ];
        let _ = p.read_struct_begin(|_| ())?;
        let mut once = false;
        let mut alt = ::std::option::Option::None;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32, once) {
                (::fbthrift::TType::Stop, _, _) => break,
                (::fbthrift::TType::Bool, 1, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::bool_val(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::I64, 2, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::integer(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::I64, 3, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::id(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Float, 4, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::single_precision(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Double, 5, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::double_precision(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::String, 6, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::str(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::I64, 7, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::timestamp(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::I16, 8, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::year(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Struct, 9, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::month(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Struct, 10, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::date(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Struct, 11, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::datetime(::fbthrift::Deserialize::read(p)?));
                }
                (::fbthrift::TType::Struct, 41, false) => {
                    once = true;
                    alt = ::std::option::Option::Some(Self::path(::fbthrift::Deserialize::read(p)?));
                }
                (fty, _, false) => p.skip(fty)?,
                (badty, badid, true) => return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
                    ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
                    format!(
                        "unwanted extra union {} field ty {:?} id {}",
                        "ColumnValue",
                        badty,
                        badid,
                    ),
                ))),
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(alt.unwrap_or_default())
    }
}

#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::RowValue {
    fn default() -> Self {
        Self {
            columns: ::std::default::Default::default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::RowValue {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("RowValue")
            .field("columns", &self.columns)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::RowValue {}
unsafe impl ::std::marker::Sync for self::RowValue {}

impl ::fbthrift::GetTType for self::RowValue {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::RowValue
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("RowValue");
        p.write_field_begin("columns", ::fbthrift::TType::List, 1);
        ::fbthrift::Serialize::write(&self.columns, p);
        p.write_field_end();
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::RowValue
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("columns", ::fbthrift::TType::List, 1),
        ];
        let mut field_columns = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::List, 1) => field_columns = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            columns: field_columns.unwrap_or_default(),
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::ExecutionResponse {
    fn default() -> Self {
        Self {
            error_code: ::std::default::Default::default(),
            latency_in_us: ::std::default::Default::default(),
            error_msg: ::std::option::Option::None,
            column_names: ::std::option::Option::None,
            rows: ::std::option::Option::None,
            space_name: ::std::option::Option::None,
            warning_msg: ::std::option::Option::None,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::ExecutionResponse {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("ExecutionResponse")
            .field("error_code", &self.error_code)
            .field("latency_in_us", &self.latency_in_us)
            .field("error_msg", &self.error_msg)
            .field("column_names", &self.column_names)
            .field("rows", &self.rows)
            .field("space_name", &self.space_name)
            .field("warning_msg", &self.warning_msg)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::ExecutionResponse {}
unsafe impl ::std::marker::Sync for self::ExecutionResponse {}

impl ::fbthrift::GetTType for self::ExecutionResponse {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::ExecutionResponse
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("ExecutionResponse");
        p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
        ::fbthrift::Serialize::write(&self.error_code, p);
        p.write_field_end();
        p.write_field_begin("latency_in_us", ::fbthrift::TType::I32, 2);
        ::fbthrift::Serialize::write(&self.latency_in_us, p);
        p.write_field_end();
        if let ::std::option::Option::Some(some) = &self.error_msg {
            p.write_field_begin("error_msg", ::fbthrift::TType::String, 3);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.column_names {
            p.write_field_begin("column_names", ::fbthrift::TType::List, 4);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.rows {
            p.write_field_begin("rows", ::fbthrift::TType::List, 5);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.space_name {
            p.write_field_begin("space_name", ::fbthrift::TType::String, 6);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.warning_msg {
            p.write_field_begin("warning_msg", ::fbthrift::TType::String, 7);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::ExecutionResponse
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("column_names", ::fbthrift::TType::List, 4),
            ::fbthrift::Field::new("error_code", ::fbthrift::TType::I32, 1),
            ::fbthrift::Field::new("error_msg", ::fbthrift::TType::String, 3),
            ::fbthrift::Field::new("latency_in_us", ::fbthrift::TType::I32, 2),
            ::fbthrift::Field::new("rows", ::fbthrift::TType::List, 5),
            ::fbthrift::Field::new("space_name", ::fbthrift::TType::String, 6),
            ::fbthrift::Field::new("warning_msg", ::fbthrift::TType::String, 7),
        ];
        let mut field_error_code = ::std::option::Option::None;
        let mut field_latency_in_us = ::std::option::Option::None;
        let mut field_error_msg = ::std::option::Option::None;
        let mut field_column_names = ::std::option::Option::None;
        let mut field_rows = ::std::option::Option::None;
        let mut field_space_name = ::std::option::Option::None;
        let mut field_warning_msg = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I32, 2) => field_latency_in_us = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 3) => field_error_msg = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::List, 4) => field_column_names = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::List, 5) => field_rows = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 6) => field_space_name = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 7) => field_warning_msg = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            error_code: field_error_code.unwrap_or_default(),
            latency_in_us: field_latency_in_us.unwrap_or_default(),
            error_msg: field_error_msg,
            column_names: field_column_names,
            rows: field_rows,
            space_name: field_space_name,
            warning_msg: field_warning_msg,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


#[allow(clippy::derivable_impls)]
impl ::std::default::Default for self::AuthResponse {
    fn default() -> Self {
        Self {
            error_code: ::std::default::Default::default(),
            session_id: ::std::option::Option::None,
            error_msg: ::std::option::Option::None,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        }
    }
}

impl ::std::fmt::Debug for self::AuthResponse {
    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter
            .debug_struct("AuthResponse")
            .field("error_code", &self.error_code)
            .field("session_id", &self.session_id)
            .field("error_msg", &self.error_msg)
            .finish()
    }
}

unsafe impl ::std::marker::Send for self::AuthResponse {}
unsafe impl ::std::marker::Sync for self::AuthResponse {}

impl ::fbthrift::GetTType for self::AuthResponse {
    const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
}

impl<P> ::fbthrift::Serialize<P> for self::AuthResponse
where
    P: ::fbthrift::ProtocolWriter,
{
    fn write(&self, p: &mut P) {
        p.write_struct_begin("AuthResponse");
        p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
        ::fbthrift::Serialize::write(&self.error_code, p);
        p.write_field_end();
        if let ::std::option::Option::Some(some) = &self.session_id {
            p.write_field_begin("session_id", ::fbthrift::TType::I64, 2);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        if let ::std::option::Option::Some(some) = &self.error_msg {
            p.write_field_begin("error_msg", ::fbthrift::TType::String, 3);
            ::fbthrift::Serialize::write(some, p);
            p.write_field_end();
        }
        p.write_field_stop();
        p.write_struct_end();
    }
}

impl<P> ::fbthrift::Deserialize<P> for self::AuthResponse
where
    P: ::fbthrift::ProtocolReader,
{
    fn read(p: &mut P) -> ::anyhow::Result<Self> {
        static FIELDS: &[::fbthrift::Field] = &[
            ::fbthrift::Field::new("error_code", ::fbthrift::TType::I32, 1),
            ::fbthrift::Field::new("error_msg", ::fbthrift::TType::String, 3),
            ::fbthrift::Field::new("session_id", ::fbthrift::TType::I64, 2),
        ];
        let mut field_error_code = ::std::option::Option::None;
        let mut field_session_id = ::std::option::Option::None;
        let mut field_error_msg = ::std::option::Option::None;
        let _ = p.read_struct_begin(|_| ())?;
        loop {
            let (_, fty, fid) = p.read_field_begin(|_| (), FIELDS)?;
            match (fty, fid as ::std::primitive::i32) {
                (::fbthrift::TType::Stop, _) => break,
                (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::I64, 2) => field_session_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (::fbthrift::TType::String, 3) => field_error_msg = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
                (fty, _) => p.skip(fty)?,
            }
            p.read_field_end()?;
        }
        p.read_struct_end()?;
        ::std::result::Result::Ok(Self {
            error_code: field_error_code.unwrap_or_default(),
            session_id: field_session_id,
            error_msg: field_error_msg,
            _dot_dot_Default_default: self::dot_dot::OtherFields(()),
        })
    }
}


mod dot_dot {
    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OtherFields(pub(crate) ());

    #[allow(dead_code)] // if serde isn't being used
    pub(super) fn default_for_serde_deserialize() -> OtherFields {
        OtherFields(())
    }
}