plexus_serde/

plexus_generated.rs

// automatically generated by the FlatBuffers compiler, do not modify
// @generated
extern crate alloc;

#[allow(unused_imports, dead_code)]
pub mod plexus {

    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_CAPABILITY_ORDERING_CONTRACT: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_CAPABILITY_ORDERING_CONTRACT: u8 = 6;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_CAPABILITY_ORDERING_CONTRACT: [CapabilityOrderingContract; 7] = [
        CapabilityOrderingContract::engine_defined_stable,
        CapabilityOrderingContract::stable_pass_through,
        CapabilityOrderingContract::fan_out_deterministic_per_input,
        CapabilityOrderingContract::deterministic_sort_stable_ties,
        CapabilityOrderingContract::unspecified_without_sort,
        CapabilityOrderingContract::stable_concat_or_unspecified_distinct,
        CapabilityOrderingContract::score_desc_stable_ties,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct CapabilityOrderingContract(pub u8);
    #[allow(non_upper_case_globals)]
    impl CapabilityOrderingContract {
        pub const engine_defined_stable: Self = Self(0);
        pub const stable_pass_through: Self = Self(1);
        pub const fan_out_deterministic_per_input: Self = Self(2);
        pub const deterministic_sort_stable_ties: Self = Self(3);
        pub const unspecified_without_sort: Self = Self(4);
        pub const stable_concat_or_unspecified_distinct: Self = Self(5);
        pub const score_desc_stable_ties: Self = Self(6);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 6;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::engine_defined_stable,
            Self::stable_pass_through,
            Self::fan_out_deterministic_per_input,
            Self::deterministic_sort_stable_ties,
            Self::unspecified_without_sort,
            Self::stable_concat_or_unspecified_distinct,
            Self::score_desc_stable_ties,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::engine_defined_stable => Some("engine_defined_stable"),
                Self::stable_pass_through => Some("stable_pass_through"),
                Self::fan_out_deterministic_per_input => Some("fan_out_deterministic_per_input"),
                Self::deterministic_sort_stable_ties => Some("deterministic_sort_stable_ties"),
                Self::unspecified_without_sort => Some("unspecified_without_sort"),
                Self::stable_concat_or_unspecified_distinct => {
                    Some("stable_concat_or_unspecified_distinct")
                }
                Self::score_desc_stable_ties => Some("score_desc_stable_ties"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for CapabilityOrderingContract {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for CapabilityOrderingContract {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for CapabilityOrderingContract {
        type Output = CapabilityOrderingContract;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for CapabilityOrderingContract {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for CapabilityOrderingContract {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for CapabilityOrderingContract {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_COL_KIND: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_COL_KIND: u8 = 12;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_COL_KIND: [ColKind; 13] = [
        ColKind::node,
        ColKind::rel,
        ColKind::value,
        ColKind::bool,
        ColKind::int64,
        ColKind::float64,
        ColKind::string,
        ColKind::null,
        ColKind::list,
        ColKind::map,
        ColKind::path,
        ColKind::graph,
        ColKind::vector,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct ColKind(pub u8);
    #[allow(non_upper_case_globals)]
    impl ColKind {
        pub const node: Self = Self(0);
        pub const rel: Self = Self(1);
        pub const value: Self = Self(2);
        pub const bool: Self = Self(3);
        pub const int64: Self = Self(4);
        pub const float64: Self = Self(5);
        pub const string: Self = Self(6);
        pub const null: Self = Self(7);
        pub const list: Self = Self(8);
        pub const map: Self = Self(9);
        pub const path: Self = Self(10);
        pub const graph: Self = Self(11);
        pub const vector: Self = Self(12);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 12;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::node,
            Self::rel,
            Self::value,
            Self::bool,
            Self::int64,
            Self::float64,
            Self::string,
            Self::null,
            Self::list,
            Self::map,
            Self::path,
            Self::graph,
            Self::vector,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::node => Some("node"),
                Self::rel => Some("rel"),
                Self::value => Some("value"),
                Self::bool => Some("bool"),
                Self::int64 => Some("int64"),
                Self::float64 => Some("float64"),
                Self::string => Some("string"),
                Self::null => Some("null"),
                Self::list => Some("list"),
                Self::map => Some("map"),
                Self::path => Some("path"),
                Self::graph => Some("graph"),
                Self::vector => Some("vector"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for ColKind {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for ColKind {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for ColKind {
        type Output = ColKind;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for ColKind {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for ColKind {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for ColKind {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_LOGICAL_TYPE: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_LOGICAL_TYPE: u8 = 11;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_LOGICAL_TYPE: [LogicalType; 12] = [
        LogicalType::unknown,
        LogicalType::bool,
        LogicalType::int64,
        LogicalType::float64,
        LogicalType::string,
        LogicalType::null,
        LogicalType::list,
        LogicalType::map,
        LogicalType::node_ref,
        LogicalType::rel_ref,
        LogicalType::path,
        LogicalType::vector,
    ];

    /// Structured logical type for a column.
    /// Added in plan format 0.3.0 alongside the deprecated string field.
    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct LogicalType(pub u8);
    #[allow(non_upper_case_globals)]
    impl LogicalType {
        pub const unknown: Self = Self(0);
        pub const bool: Self = Self(1);
        pub const int64: Self = Self(2);
        pub const float64: Self = Self(3);
        pub const string: Self = Self(4);
        pub const null: Self = Self(5);
        pub const list: Self = Self(6);
        pub const map: Self = Self(7);
        pub const node_ref: Self = Self(8);
        pub const rel_ref: Self = Self(9);
        pub const path: Self = Self(10);
        pub const vector: Self = Self(11);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 11;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::unknown,
            Self::bool,
            Self::int64,
            Self::float64,
            Self::string,
            Self::null,
            Self::list,
            Self::map,
            Self::node_ref,
            Self::rel_ref,
            Self::path,
            Self::vector,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::unknown => Some("unknown"),
                Self::bool => Some("bool"),
                Self::int64 => Some("int64"),
                Self::float64 => Some("float64"),
                Self::string => Some("string"),
                Self::null => Some("null"),
                Self::list => Some("list"),
                Self::map => Some("map"),
                Self::node_ref => Some("node_ref"),
                Self::rel_ref => Some("rel_ref"),
                Self::path => Some("path"),
                Self::vector => Some("vector"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for LogicalType {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for LogicalType {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for LogicalType {
        type Output = LogicalType;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for LogicalType {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for LogicalType {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for LogicalType {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_CMP_OP: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_CMP_OP: u8 = 5;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_CMP_OP: [CmpOp; 6] = [
        CmpOp::eq,
        CmpOp::ne,
        CmpOp::lt,
        CmpOp::gt,
        CmpOp::le,
        CmpOp::ge,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct CmpOp(pub u8);
    #[allow(non_upper_case_globals)]
    impl CmpOp {
        pub const eq: Self = Self(0);
        pub const ne: Self = Self(1);
        pub const lt: Self = Self(2);
        pub const gt: Self = Self(3);
        pub const le: Self = Self(4);
        pub const ge: Self = Self(5);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 5;
        pub const ENUM_VALUES: &'static [Self] =
            &[Self::eq, Self::ne, Self::lt, Self::gt, Self::le, Self::ge];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::eq => Some("eq"),
                Self::ne => Some("ne"),
                Self::lt => Some("lt"),
                Self::gt => Some("gt"),
                Self::le => Some("le"),
                Self::ge => Some("ge"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for CmpOp {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for CmpOp {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for CmpOp {
        type Output = CmpOp;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for CmpOp {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for CmpOp {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for CmpOp {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_AGG_FN: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_AGG_FN: u8 = 6;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_AGG_FN: [AggFn; 7] = [
        AggFn::count_star,
        AggFn::count,
        AggFn::sum,
        AggFn::avg,
        AggFn::min,
        AggFn::max,
        AggFn::collect,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct AggFn(pub u8);
    #[allow(non_upper_case_globals)]
    impl AggFn {
        pub const count_star: Self = Self(0);
        pub const count: Self = Self(1);
        pub const sum: Self = Self(2);
        pub const avg: Self = Self(3);
        pub const min: Self = Self(4);
        pub const max: Self = Self(5);
        pub const collect: Self = Self(6);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 6;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::count_star,
            Self::count,
            Self::sum,
            Self::avg,
            Self::min,
            Self::max,
            Self::collect,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::count_star => Some("count_star"),
                Self::count => Some("count"),
                Self::sum => Some("sum"),
                Self::avg => Some("avg"),
                Self::min => Some("min"),
                Self::max => Some("max"),
                Self::collect => Some("collect"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for AggFn {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for AggFn {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for AggFn {
        type Output = AggFn;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for AggFn {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for AggFn {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for AggFn {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_ARITH_OP: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_ARITH_OP: u8 = 3;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_ARITH_OP: [ArithOp; 4] =
        [ArithOp::add, ArithOp::sub, ArithOp::mul, ArithOp::div];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct ArithOp(pub u8);
    #[allow(non_upper_case_globals)]
    impl ArithOp {
        pub const add: Self = Self(0);
        pub const sub: Self = Self(1);
        pub const mul: Self = Self(2);
        pub const div: Self = Self(3);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 3;
        pub const ENUM_VALUES: &'static [Self] = &[Self::add, Self::sub, Self::mul, Self::div];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::add => Some("add"),
                Self::sub => Some("sub"),
                Self::mul => Some("mul"),
                Self::div => Some("div"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for ArithOp {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for ArithOp {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for ArithOp {
        type Output = ArithOp;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for ArithOp {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for ArithOp {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for ArithOp {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_VECTOR_METRIC: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_VECTOR_METRIC: u8 = 2;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_VECTOR_METRIC: [VectorMetric; 3] = [
        VectorMetric::cosine,
        VectorMetric::l2,
        VectorMetric::dot_product,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct VectorMetric(pub u8);
    #[allow(non_upper_case_globals)]
    impl VectorMetric {
        pub const cosine: Self = Self(0);
        pub const l2: Self = Self(1);
        pub const dot_product: Self = Self(2);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 2;
        pub const ENUM_VALUES: &'static [Self] = &[Self::cosine, Self::l2, Self::dot_product];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::cosine => Some("cosine"),
                Self::l2 => Some("l2"),
                Self::dot_product => Some("dot_product"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for VectorMetric {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for VectorMetric {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for VectorMetric {
        type Output = VectorMetric;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for VectorMetric {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for VectorMetric {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for VectorMetric {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_EXPR_NODE: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_EXPR_NODE: u8 = 26;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_EXPR_NODE: [ExprNode; 27] = [
        ExprNode::NONE,
        ExprNode::ColRefExpr,
        ExprNode::PropAccessExpr,
        ExprNode::IntLiteralExpr,
        ExprNode::FloatLiteralExpr,
        ExprNode::BoolLiteralExpr,
        ExprNode::StringLiteralExpr,
        ExprNode::NullLiteralExpr,
        ExprNode::CmpExpr,
        ExprNode::AndExpr,
        ExprNode::OrExpr,
        ExprNode::NotExpr,
        ExprNode::IsNullExpr,
        ExprNode::IsNotNullExpr,
        ExprNode::StartsWithExpr,
        ExprNode::EndsWithExpr,
        ExprNode::ContainsExpr,
        ExprNode::InExpr,
        ExprNode::ListLiteralExpr,
        ExprNode::MapLiteralExpr,
        ExprNode::ExistsExpr,
        ExprNode::ListComprehensionExpr,
        ExprNode::AggExpr,
        ExprNode::ArithExpr,
        ExprNode::ParamExpr,
        ExprNode::CaseExpr,
        ExprNode::VectorSimilarityExpr,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct ExprNode(pub u8);
    #[allow(non_upper_case_globals)]
    impl ExprNode {
        pub const NONE: Self = Self(0);
        pub const ColRefExpr: Self = Self(1);
        pub const PropAccessExpr: Self = Self(2);
        pub const IntLiteralExpr: Self = Self(3);
        pub const FloatLiteralExpr: Self = Self(4);
        pub const BoolLiteralExpr: Self = Self(5);
        pub const StringLiteralExpr: Self = Self(6);
        pub const NullLiteralExpr: Self = Self(7);
        pub const CmpExpr: Self = Self(8);
        pub const AndExpr: Self = Self(9);
        pub const OrExpr: Self = Self(10);
        pub const NotExpr: Self = Self(11);
        pub const IsNullExpr: Self = Self(12);
        pub const IsNotNullExpr: Self = Self(13);
        pub const StartsWithExpr: Self = Self(14);
        pub const EndsWithExpr: Self = Self(15);
        pub const ContainsExpr: Self = Self(16);
        pub const InExpr: Self = Self(17);
        pub const ListLiteralExpr: Self = Self(18);
        pub const MapLiteralExpr: Self = Self(19);
        pub const ExistsExpr: Self = Self(20);
        pub const ListComprehensionExpr: Self = Self(21);
        pub const AggExpr: Self = Self(22);
        pub const ArithExpr: Self = Self(23);
        pub const ParamExpr: Self = Self(24);
        pub const CaseExpr: Self = Self(25);
        pub const VectorSimilarityExpr: Self = Self(26);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 26;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::NONE,
            Self::ColRefExpr,
            Self::PropAccessExpr,
            Self::IntLiteralExpr,
            Self::FloatLiteralExpr,
            Self::BoolLiteralExpr,
            Self::StringLiteralExpr,
            Self::NullLiteralExpr,
            Self::CmpExpr,
            Self::AndExpr,
            Self::OrExpr,
            Self::NotExpr,
            Self::IsNullExpr,
            Self::IsNotNullExpr,
            Self::StartsWithExpr,
            Self::EndsWithExpr,
            Self::ContainsExpr,
            Self::InExpr,
            Self::ListLiteralExpr,
            Self::MapLiteralExpr,
            Self::ExistsExpr,
            Self::ListComprehensionExpr,
            Self::AggExpr,
            Self::ArithExpr,
            Self::ParamExpr,
            Self::CaseExpr,
            Self::VectorSimilarityExpr,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::NONE => Some("NONE"),
                Self::ColRefExpr => Some("ColRefExpr"),
                Self::PropAccessExpr => Some("PropAccessExpr"),
                Self::IntLiteralExpr => Some("IntLiteralExpr"),
                Self::FloatLiteralExpr => Some("FloatLiteralExpr"),
                Self::BoolLiteralExpr => Some("BoolLiteralExpr"),
                Self::StringLiteralExpr => Some("StringLiteralExpr"),
                Self::NullLiteralExpr => Some("NullLiteralExpr"),
                Self::CmpExpr => Some("CmpExpr"),
                Self::AndExpr => Some("AndExpr"),
                Self::OrExpr => Some("OrExpr"),
                Self::NotExpr => Some("NotExpr"),
                Self::IsNullExpr => Some("IsNullExpr"),
                Self::IsNotNullExpr => Some("IsNotNullExpr"),
                Self::StartsWithExpr => Some("StartsWithExpr"),
                Self::EndsWithExpr => Some("EndsWithExpr"),
                Self::ContainsExpr => Some("ContainsExpr"),
                Self::InExpr => Some("InExpr"),
                Self::ListLiteralExpr => Some("ListLiteralExpr"),
                Self::MapLiteralExpr => Some("MapLiteralExpr"),
                Self::ExistsExpr => Some("ExistsExpr"),
                Self::ListComprehensionExpr => Some("ListComprehensionExpr"),
                Self::AggExpr => Some("AggExpr"),
                Self::ArithExpr => Some("ArithExpr"),
                Self::ParamExpr => Some("ParamExpr"),
                Self::CaseExpr => Some("CaseExpr"),
                Self::VectorSimilarityExpr => Some("VectorSimilarityExpr"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for ExprNode {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for ExprNode {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for ExprNode {
        type Output = ExprNode;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for ExprNode {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for ExprNode {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for ExprNode {}
    pub struct ExprNodeUnionTableOffset {}

    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_EXPAND_DIR: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_EXPAND_DIR: u8 = 2;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_EXPAND_DIR: [ExpandDir; 3] =
        [ExpandDir::out, ExpandDir::in_, ExpandDir::both];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct ExpandDir(pub u8);
    #[allow(non_upper_case_globals)]
    impl ExpandDir {
        pub const out: Self = Self(0);
        pub const in_: Self = Self(1);
        pub const both: Self = Self(2);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 2;
        pub const ENUM_VALUES: &'static [Self] = &[Self::out, Self::in_, Self::both];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::out => Some("out"),
                Self::in_ => Some("in_"),
                Self::both => Some("both"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for ExpandDir {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for ExpandDir {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for ExpandDir {
        type Output = ExpandDir;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for ExpandDir {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for ExpandDir {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for ExpandDir {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_SORT_DIR: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_SORT_DIR: u8 = 1;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_SORT_DIR: [SortDir; 2] = [SortDir::asc, SortDir::desc];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct SortDir(pub u8);
    #[allow(non_upper_case_globals)]
    impl SortDir {
        pub const asc: Self = Self(0);
        pub const desc: Self = Self(1);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 1;
        pub const ENUM_VALUES: &'static [Self] = &[Self::asc, Self::desc];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::asc => Some("asc"),
                Self::desc => Some("desc"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for SortDir {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for SortDir {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for SortDir {
        type Output = SortDir;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for SortDir {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for SortDir {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for SortDir {}
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MIN_OP_NODE: u8 = 0;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    pub const ENUM_MAX_OP_NODE: u8 = 25;
    #[deprecated(
        since = "2.0.0",
        note = "Use associated constants instead. This will no longer be generated in 2021."
    )]
    #[allow(non_camel_case_types)]
    pub const ENUM_VALUES_OP_NODE: [OpNode; 26] = [
        OpNode::NONE,
        OpNode::ScanNodesOp,
        OpNode::ScanRelsOp,
        OpNode::ExpandOp,
        OpNode::OptionalExpandOp,
        OpNode::SemiExpandOp,
        OpNode::ExpandVarLenOp,
        OpNode::FilterOp,
        OpNode::BlockMarkerOp,
        OpNode::ProjectOp,
        OpNode::AggregateOp,
        OpNode::SortOp,
        OpNode::LimitOp,
        OpNode::UnwindOp,
        OpNode::PathConstructOp,
        OpNode::UnionOp,
        OpNode::CreateNodeOp,
        OpNode::CreateRelOp,
        OpNode::MergeOp,
        OpNode::DeleteOp,
        OpNode::SetPropertyOp,
        OpNode::RemovePropertyOp,
        OpNode::VectorScanOp,
        OpNode::RerankOp,
        OpNode::ReturnOp,
        OpNode::ConstRowOp,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct OpNode(pub u8);
    #[allow(non_upper_case_globals)]
    impl OpNode {
        pub const NONE: Self = Self(0);
        pub const ScanNodesOp: Self = Self(1);
        pub const ScanRelsOp: Self = Self(2);
        pub const ExpandOp: Self = Self(3);
        pub const OptionalExpandOp: Self = Self(4);
        pub const SemiExpandOp: Self = Self(5);
        pub const ExpandVarLenOp: Self = Self(6);
        pub const FilterOp: Self = Self(7);
        pub const BlockMarkerOp: Self = Self(8);
        pub const ProjectOp: Self = Self(9);
        pub const AggregateOp: Self = Self(10);
        pub const SortOp: Self = Self(11);
        pub const LimitOp: Self = Self(12);
        pub const UnwindOp: Self = Self(13);
        pub const PathConstructOp: Self = Self(14);
        pub const UnionOp: Self = Self(15);
        pub const CreateNodeOp: Self = Self(16);
        pub const CreateRelOp: Self = Self(17);
        pub const MergeOp: Self = Self(18);
        pub const DeleteOp: Self = Self(19);
        pub const SetPropertyOp: Self = Self(20);
        pub const RemovePropertyOp: Self = Self(21);
        pub const VectorScanOp: Self = Self(22);
        pub const RerankOp: Self = Self(23);
        pub const ReturnOp: Self = Self(24);
        pub const ConstRowOp: Self = Self(25);

        pub const ENUM_MIN: u8 = 0;
        pub const ENUM_MAX: u8 = 25;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::NONE,
            Self::ScanNodesOp,
            Self::ScanRelsOp,
            Self::ExpandOp,
            Self::OptionalExpandOp,
            Self::SemiExpandOp,
            Self::ExpandVarLenOp,
            Self::FilterOp,
            Self::BlockMarkerOp,
            Self::ProjectOp,
            Self::AggregateOp,
            Self::SortOp,
            Self::LimitOp,
            Self::UnwindOp,
            Self::PathConstructOp,
            Self::UnionOp,
            Self::CreateNodeOp,
            Self::CreateRelOp,
            Self::MergeOp,
            Self::DeleteOp,
            Self::SetPropertyOp,
            Self::RemovePropertyOp,
            Self::VectorScanOp,
            Self::RerankOp,
            Self::ReturnOp,
            Self::ConstRowOp,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::NONE => Some("NONE"),
                Self::ScanNodesOp => Some("ScanNodesOp"),
                Self::ScanRelsOp => Some("ScanRelsOp"),
                Self::ExpandOp => Some("ExpandOp"),
                Self::OptionalExpandOp => Some("OptionalExpandOp"),
                Self::SemiExpandOp => Some("SemiExpandOp"),
                Self::ExpandVarLenOp => Some("ExpandVarLenOp"),
                Self::FilterOp => Some("FilterOp"),
                Self::BlockMarkerOp => Some("BlockMarkerOp"),
                Self::ProjectOp => Some("ProjectOp"),
                Self::AggregateOp => Some("AggregateOp"),
                Self::SortOp => Some("SortOp"),
                Self::LimitOp => Some("LimitOp"),
                Self::UnwindOp => Some("UnwindOp"),
                Self::PathConstructOp => Some("PathConstructOp"),
                Self::UnionOp => Some("UnionOp"),
                Self::CreateNodeOp => Some("CreateNodeOp"),
                Self::CreateRelOp => Some("CreateRelOp"),
                Self::MergeOp => Some("MergeOp"),
                Self::DeleteOp => Some("DeleteOp"),
                Self::SetPropertyOp => Some("SetPropertyOp"),
                Self::RemovePropertyOp => Some("RemovePropertyOp"),
                Self::VectorScanOp => Some("VectorScanOp"),
                Self::RerankOp => Some("RerankOp"),
                Self::ReturnOp => Some("ReturnOp"),
                Self::ConstRowOp => Some("ConstRowOp"),
                _ => None,
            }
        }
    }
    impl ::core::fmt::Debug for OpNode {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            if let Some(name) = self.variant_name() {
                f.write_str(name)
            } else {
                f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
            }
        }
    }
    impl<'a> ::flatbuffers::Follow<'a> for OpNode {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
            Self(b)
        }
    }

    impl ::flatbuffers::Push for OpNode {
        type Output = OpNode;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
        }
    }

    impl ::flatbuffers::EndianScalar for OpNode {
        type Scalar = u8;
        #[inline]
        fn to_little_endian(self) -> u8 {
            self.0.to_le()
        }
        #[inline]
        #[allow(clippy::wrong_self_convention)]
        fn from_little_endian(v: u8) -> Self {
            let b = u8::from_le(v);
            Self(b)
        }
    }

    impl<'a> ::flatbuffers::Verifiable for OpNode {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            u8::run_verifier(v, pos)
        }
    }

    impl ::flatbuffers::SimpleToVerifyInSlice for OpNode {}
    pub struct OpNodeUnionTableOffset {}

    pub enum VersionOffset {}
    #[derive(Copy, Clone, PartialEq)]

    /// Semantic version of the Plexus plan format.
    /// Embedded in every serialized PlexusPlan.
    pub struct Version<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for Version<'a> {
        type Inner = Version<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> Version<'a> {
        pub const VT_MAJOR: ::flatbuffers::VOffsetT = 4;
        pub const VT_MINOR: ::flatbuffers::VOffsetT = 6;
        pub const VT_PATCH: ::flatbuffers::VOffsetT = 8;
        pub const VT_PRODUCER: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            Version { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args VersionArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<Version<'bldr>> {
            let mut builder = VersionBuilder::new(_fbb);
            if let Some(x) = args.producer {
                builder.add_producer(x);
            }
            builder.add_patch(args.patch);
            builder.add_minor(args.minor);
            builder.add_major(args.major);
            builder.finish()
        }

        #[inline]
        pub fn major(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(Version::VT_MAJOR, Some(0)).unwrap() }
        }
        #[inline]
        pub fn minor(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(Version::VT_MINOR, Some(0)).unwrap() }
        }
        #[inline]
        pub fn patch(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(Version::VT_PATCH, Some(0)).unwrap() }
        }
        /// Human-readable producer identification, e.g. "plexus-rs 0.1.0".
        #[inline]
        pub fn producer(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(Version::VT_PRODUCER, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for Version<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("major", Self::VT_MAJOR, false)?
                .visit_field::<u32>("minor", Self::VT_MINOR, false)?
                .visit_field::<u32>("patch", Self::VT_PATCH, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "producer",
                    Self::VT_PRODUCER,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct VersionArgs<'a> {
        pub major: u32,
        pub minor: u32,
        pub patch: u32,
        pub producer: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for VersionArgs<'a> {
        #[inline]
        fn default() -> Self {
            VersionArgs {
                major: 0,
                minor: 0,
                patch: 0,
                producer: None,
            }
        }
    }

    pub struct VersionBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> VersionBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_major(&mut self, major: u32) {
            self.fbb_.push_slot::<u32>(Version::VT_MAJOR, major, 0);
        }
        #[inline]
        pub fn add_minor(&mut self, minor: u32) {
            self.fbb_.push_slot::<u32>(Version::VT_MINOR, minor, 0);
        }
        #[inline]
        pub fn add_patch(&mut self, patch: u32) {
            self.fbb_.push_slot::<u32>(Version::VT_PATCH, patch, 0);
        }
        #[inline]
        pub fn add_producer(&mut self, producer: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Version::VT_PRODUCER, producer);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> VersionBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            VersionBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<Version<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for Version<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("Version");
            ds.field("major", &self.major());
            ds.field("minor", &self.minor());
            ds.field("patch", &self.patch());
            ds.field("producer", &self.producer());
            ds.finish()
        }
    }
    pub enum CapabilityVersionRangeOffset {}
    #[derive(Copy, Clone, PartialEq)]

    /// Capability semver range declaration for engine compatibility.
    pub struct CapabilityVersionRange<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for CapabilityVersionRange<'a> {
        type Inner = CapabilityVersionRange<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> CapabilityVersionRange<'a> {
        pub const VT_MIN_MAJOR: ::flatbuffers::VOffsetT = 4;
        pub const VT_MIN_MINOR: ::flatbuffers::VOffsetT = 6;
        pub const VT_MIN_PATCH: ::flatbuffers::VOffsetT = 8;
        pub const VT_MAX_MAJOR: ::flatbuffers::VOffsetT = 10;
        pub const VT_MAX_MINOR: ::flatbuffers::VOffsetT = 12;
        pub const VT_MAX_PATCH: ::flatbuffers::VOffsetT = 14;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            CapabilityVersionRange { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args CapabilityVersionRangeArgs,
        ) -> ::flatbuffers::WIPOffset<CapabilityVersionRange<'bldr>> {
            let mut builder = CapabilityVersionRangeBuilder::new(_fbb);
            builder.add_max_patch(args.max_patch);
            builder.add_max_minor(args.max_minor);
            builder.add_max_major(args.max_major);
            builder.add_min_patch(args.min_patch);
            builder.add_min_minor(args.min_minor);
            builder.add_min_major(args.min_major);
            builder.finish()
        }

        #[inline]
        pub fn min_major(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CapabilityVersionRange::VT_MIN_MAJOR, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn min_minor(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CapabilityVersionRange::VT_MIN_MINOR, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn min_patch(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CapabilityVersionRange::VT_MIN_PATCH, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn max_major(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CapabilityVersionRange::VT_MAX_MAJOR, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn max_minor(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CapabilityVersionRange::VT_MAX_MINOR, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn max_patch(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CapabilityVersionRange::VT_MAX_PATCH, Some(0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for CapabilityVersionRange<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("min_major", Self::VT_MIN_MAJOR, false)?
                .visit_field::<u32>("min_minor", Self::VT_MIN_MINOR, false)?
                .visit_field::<u32>("min_patch", Self::VT_MIN_PATCH, false)?
                .visit_field::<u32>("max_major", Self::VT_MAX_MAJOR, false)?
                .visit_field::<u32>("max_minor", Self::VT_MAX_MINOR, false)?
                .visit_field::<u32>("max_patch", Self::VT_MAX_PATCH, false)?
                .finish();
            Ok(())
        }
    }
    pub struct CapabilityVersionRangeArgs {
        pub min_major: u32,
        pub min_minor: u32,
        pub min_patch: u32,
        pub max_major: u32,
        pub max_minor: u32,
        pub max_patch: u32,
    }
    impl<'a> Default for CapabilityVersionRangeArgs {
        #[inline]
        fn default() -> Self {
            CapabilityVersionRangeArgs {
                min_major: 0,
                min_minor: 0,
                min_patch: 0,
                max_major: 0,
                max_minor: 0,
                max_patch: 0,
            }
        }
    }

    pub struct CapabilityVersionRangeBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CapabilityVersionRangeBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_min_major(&mut self, min_major: u32) {
            self.fbb_
                .push_slot::<u32>(CapabilityVersionRange::VT_MIN_MAJOR, min_major, 0);
        }
        #[inline]
        pub fn add_min_minor(&mut self, min_minor: u32) {
            self.fbb_
                .push_slot::<u32>(CapabilityVersionRange::VT_MIN_MINOR, min_minor, 0);
        }
        #[inline]
        pub fn add_min_patch(&mut self, min_patch: u32) {
            self.fbb_
                .push_slot::<u32>(CapabilityVersionRange::VT_MIN_PATCH, min_patch, 0);
        }
        #[inline]
        pub fn add_max_major(&mut self, max_major: u32) {
            self.fbb_
                .push_slot::<u32>(CapabilityVersionRange::VT_MAX_MAJOR, max_major, 0);
        }
        #[inline]
        pub fn add_max_minor(&mut self, max_minor: u32) {
            self.fbb_
                .push_slot::<u32>(CapabilityVersionRange::VT_MAX_MINOR, max_minor, 0);
        }
        #[inline]
        pub fn add_max_patch(&mut self, max_patch: u32) {
            self.fbb_
                .push_slot::<u32>(CapabilityVersionRange::VT_MAX_PATCH, max_patch, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> CapabilityVersionRangeBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            CapabilityVersionRangeBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<CapabilityVersionRange<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for CapabilityVersionRange<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("CapabilityVersionRange");
            ds.field("min_major", &self.min_major());
            ds.field("min_minor", &self.min_minor());
            ds.field("min_patch", &self.min_patch());
            ds.field("max_major", &self.max_major());
            ds.field("max_minor", &self.max_minor());
            ds.field("max_patch", &self.max_patch());
            ds.finish()
        }
    }
    pub enum OpOrderingDeclOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct OpOrderingDecl<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for OpOrderingDecl<'a> {
        type Inner = OpOrderingDecl<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> OpOrderingDecl<'a> {
        pub const VT_OP: ::flatbuffers::VOffsetT = 4;
        pub const VT_CONTRACT: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            OpOrderingDecl { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args OpOrderingDeclArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<OpOrderingDecl<'bldr>> {
            let mut builder = OpOrderingDeclBuilder::new(_fbb);
            if let Some(x) = args.op {
                builder.add_op(x);
            }
            builder.add_contract(args.contract);
            builder.finish()
        }

        #[inline]
        pub fn op(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(OpOrderingDecl::VT_OP, None)
            }
        }
        #[inline]
        pub fn contract(&self) -> CapabilityOrderingContract {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<CapabilityOrderingContract>(
                        OpOrderingDecl::VT_CONTRACT,
                        Some(CapabilityOrderingContract::engine_defined_stable),
                    )
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for OpOrderingDecl<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("op", Self::VT_OP, false)?
                .visit_field::<CapabilityOrderingContract>("contract", Self::VT_CONTRACT, false)?
                .finish();
            Ok(())
        }
    }
    pub struct OpOrderingDeclArgs<'a> {
        pub op: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub contract: CapabilityOrderingContract,
    }
    impl<'a> Default for OpOrderingDeclArgs<'a> {
        #[inline]
        fn default() -> Self {
            OpOrderingDeclArgs {
                op: None,
                contract: CapabilityOrderingContract::engine_defined_stable,
            }
        }
    }

    pub struct OpOrderingDeclBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OpOrderingDeclBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_op(&mut self, op: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(OpOrderingDecl::VT_OP, op);
        }
        #[inline]
        pub fn add_contract(&mut self, contract: CapabilityOrderingContract) {
            self.fbb_.push_slot::<CapabilityOrderingContract>(
                OpOrderingDecl::VT_CONTRACT,
                contract,
                CapabilityOrderingContract::engine_defined_stable,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> OpOrderingDeclBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            OpOrderingDeclBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<OpOrderingDecl<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for OpOrderingDecl<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("OpOrderingDecl");
            ds.field("op", &self.op());
            ds.field("contract", &self.contract());
            ds.finish()
        }
    }
    pub enum EngineCapabilityDeclOffset {}
    #[derive(Copy, Clone, PartialEq)]

    /// FlatBuffer block for machine-readable engine capability declaration.
    pub struct EngineCapabilityDecl<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for EngineCapabilityDecl<'a> {
        type Inner = EngineCapabilityDecl<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> EngineCapabilityDecl<'a> {
        pub const VT_VERSION_RANGE: ::flatbuffers::VOffsetT = 4;
        pub const VT_SUPPORTED_OPS: ::flatbuffers::VOffsetT = 6;
        pub const VT_SUPPORTED_EXPRS: ::flatbuffers::VOffsetT = 8;
        pub const VT_OP_ORDERING: ::flatbuffers::VOffsetT = 10;
        pub const VT_SUPPORTS_GRAPH_REF: ::flatbuffers::VOffsetT = 12;
        pub const VT_SUPPORTS_MULTI_GRAPH: ::flatbuffers::VOffsetT = 14;
        pub const VT_SUPPORTS_GRAPH_PARAMS: ::flatbuffers::VOffsetT = 16;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            EngineCapabilityDecl { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args EngineCapabilityDeclArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<EngineCapabilityDecl<'bldr>> {
            let mut builder = EngineCapabilityDeclBuilder::new(_fbb);
            if let Some(x) = args.op_ordering {
                builder.add_op_ordering(x);
            }
            if let Some(x) = args.supported_exprs {
                builder.add_supported_exprs(x);
            }
            if let Some(x) = args.supported_ops {
                builder.add_supported_ops(x);
            }
            if let Some(x) = args.version_range {
                builder.add_version_range(x);
            }
            builder.add_supports_graph_params(args.supports_graph_params);
            builder.add_supports_multi_graph(args.supports_multi_graph);
            builder.add_supports_graph_ref(args.supports_graph_ref);
            builder.finish()
        }

        #[inline]
        pub fn version_range(&self) -> CapabilityVersionRange<'a> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<CapabilityVersionRange>>(
                        EngineCapabilityDecl::VT_VERSION_RANGE,
                        None,
                    )
                    .unwrap()
            }
        }
        #[inline]
        pub fn supported_ops(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(EngineCapabilityDecl::VT_SUPPORTED_OPS, None)
            }
        }
        #[inline]
        pub fn supported_exprs(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(EngineCapabilityDecl::VT_SUPPORTED_EXPRS, None)
            }
        }
        #[inline]
        pub fn op_ordering(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OpOrderingDecl<'a>>>>
        {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OpOrderingDecl>>,
                >>(EngineCapabilityDecl::VT_OP_ORDERING, None)
            }
        }
        #[inline]
        pub fn supports_graph_ref(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(EngineCapabilityDecl::VT_SUPPORTS_GRAPH_REF, Some(false))
                    .unwrap()
            }
        }
        #[inline]
        pub fn supports_multi_graph(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(EngineCapabilityDecl::VT_SUPPORTS_MULTI_GRAPH, Some(false))
                    .unwrap()
            }
        }
        #[inline]
        pub fn supports_graph_params(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(EngineCapabilityDecl::VT_SUPPORTS_GRAPH_PARAMS, Some(false))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for EngineCapabilityDecl<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<CapabilityVersionRange>>(
                    "version_range",
                    Self::VT_VERSION_RANGE,
                    true,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("supported_ops", Self::VT_SUPPORTED_OPS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("supported_exprs", Self::VT_SUPPORTED_EXPRS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<OpOrderingDecl>>,
                >>("op_ordering", Self::VT_OP_ORDERING, false)?
                .visit_field::<bool>("supports_graph_ref", Self::VT_SUPPORTS_GRAPH_REF, false)?
                .visit_field::<bool>("supports_multi_graph", Self::VT_SUPPORTS_MULTI_GRAPH, false)?
                .visit_field::<bool>(
                    "supports_graph_params",
                    Self::VT_SUPPORTS_GRAPH_PARAMS,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct EngineCapabilityDeclArgs<'a> {
        pub version_range: Option<::flatbuffers::WIPOffset<CapabilityVersionRange<'a>>>,
        pub supported_ops: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub supported_exprs: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub op_ordering: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OpOrderingDecl<'a>>>,
            >,
        >,
        pub supports_graph_ref: bool,
        pub supports_multi_graph: bool,
        pub supports_graph_params: bool,
    }
    impl<'a> Default for EngineCapabilityDeclArgs<'a> {
        #[inline]
        fn default() -> Self {
            EngineCapabilityDeclArgs {
                version_range: None, // required field
                supported_ops: None,
                supported_exprs: None,
                op_ordering: None,
                supports_graph_ref: false,
                supports_multi_graph: false,
                supports_graph_params: false,
            }
        }
    }

    pub struct EngineCapabilityDeclBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> EngineCapabilityDeclBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_version_range(
            &mut self,
            version_range: ::flatbuffers::WIPOffset<CapabilityVersionRange<'b>>,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<CapabilityVersionRange>>(
                    EngineCapabilityDecl::VT_VERSION_RANGE,
                    version_range,
                );
        }
        #[inline]
        pub fn add_supported_ops(
            &mut self,
            supported_ops: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                EngineCapabilityDecl::VT_SUPPORTED_OPS,
                supported_ops,
            );
        }
        #[inline]
        pub fn add_supported_exprs(
            &mut self,
            supported_exprs: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                EngineCapabilityDecl::VT_SUPPORTED_EXPRS,
                supported_exprs,
            );
        }
        #[inline]
        pub fn add_op_ordering(
            &mut self,
            op_ordering: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<OpOrderingDecl<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                EngineCapabilityDecl::VT_OP_ORDERING,
                op_ordering,
            );
        }
        #[inline]
        pub fn add_supports_graph_ref(&mut self, supports_graph_ref: bool) {
            self.fbb_.push_slot::<bool>(
                EngineCapabilityDecl::VT_SUPPORTS_GRAPH_REF,
                supports_graph_ref,
                false,
            );
        }
        #[inline]
        pub fn add_supports_multi_graph(&mut self, supports_multi_graph: bool) {
            self.fbb_.push_slot::<bool>(
                EngineCapabilityDecl::VT_SUPPORTS_MULTI_GRAPH,
                supports_multi_graph,
                false,
            );
        }
        #[inline]
        pub fn add_supports_graph_params(&mut self, supports_graph_params: bool) {
            self.fbb_.push_slot::<bool>(
                EngineCapabilityDecl::VT_SUPPORTS_GRAPH_PARAMS,
                supports_graph_params,
                false,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> EngineCapabilityDeclBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            EngineCapabilityDeclBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<EngineCapabilityDecl<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_
                .required(o, EngineCapabilityDecl::VT_VERSION_RANGE, "version_range");
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for EngineCapabilityDecl<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("EngineCapabilityDecl");
            ds.field("version_range", &self.version_range());
            ds.field("supported_ops", &self.supported_ops());
            ds.field("supported_exprs", &self.supported_exprs());
            ds.field("op_ordering", &self.op_ordering());
            ds.field("supports_graph_ref", &self.supports_graph_ref());
            ds.field("supports_multi_graph", &self.supports_multi_graph());
            ds.field("supports_graph_params", &self.supports_graph_params());
            ds.finish()
        }
    }
    pub enum ColDefOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ColDef<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ColDef<'a> {
        type Inner = ColDef<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ColDef<'a> {
        pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
        pub const VT_KIND: ::flatbuffers::VOffsetT = 6;
        pub const VT_LOGICAL_TYPE: ::flatbuffers::VOffsetT = 8;
        pub const VT_LOGICAL_TYPE_KIND: ::flatbuffers::VOffsetT = 10;
        pub const VT_VECTOR_ELEMENT_TYPE: ::flatbuffers::VOffsetT = 12;
        pub const VT_VECTOR_DIMENSION: ::flatbuffers::VOffsetT = 14;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ColDef { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ColDefArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ColDef<'bldr>> {
            let mut builder = ColDefBuilder::new(_fbb);
            builder.add_vector_dimension(args.vector_dimension);
            if let Some(x) = args.vector_element_type {
                builder.add_vector_element_type(x);
            }
            if let Some(x) = args.logical_type {
                builder.add_logical_type(x);
            }
            if let Some(x) = args.name {
                builder.add_name(x);
            }
            builder.add_logical_type_kind(args.logical_type_kind);
            builder.add_kind(args.kind);
            builder.finish()
        }

        #[inline]
        pub fn name(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ColDef::VT_NAME, None)
            }
        }
        #[inline]
        pub fn kind(&self) -> ColKind {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ColKind>(ColDef::VT_KIND, Some(ColKind::value))
                    .unwrap()
            }
        }
        #[inline]
        pub fn logical_type(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ColDef::VT_LOGICAL_TYPE, None)
            }
        }
        #[inline]
        pub fn logical_type_kind(&self) -> LogicalType {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<LogicalType>(ColDef::VT_LOGICAL_TYPE_KIND, Some(LogicalType::unknown))
                    .unwrap()
            }
        }
        #[inline]
        pub fn vector_element_type(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                    ColDef::VT_VECTOR_ELEMENT_TYPE,
                    None,
                )
            }
        }
        #[inline]
        pub fn vector_dimension(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(ColDef::VT_VECTOR_DIMENSION, Some(0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for ColDef<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
                .visit_field::<ColKind>("kind", Self::VT_KIND, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "logical_type",
                    Self::VT_LOGICAL_TYPE,
                    false,
                )?
                .visit_field::<LogicalType>("logical_type_kind", Self::VT_LOGICAL_TYPE_KIND, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "vector_element_type",
                    Self::VT_VECTOR_ELEMENT_TYPE,
                    false,
                )?
                .visit_field::<u32>("vector_dimension", Self::VT_VECTOR_DIMENSION, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ColDefArgs<'a> {
        pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub kind: ColKind,
        pub logical_type: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub logical_type_kind: LogicalType,
        pub vector_element_type: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub vector_dimension: u32,
    }
    impl<'a> Default for ColDefArgs<'a> {
        #[inline]
        fn default() -> Self {
            ColDefArgs {
                name: None,
                kind: ColKind::value,
                logical_type: None,
                logical_type_kind: LogicalType::unknown,
                vector_element_type: None,
                vector_dimension: 0,
            }
        }
    }

    pub struct ColDefBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ColDefBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ColDef::VT_NAME, name);
        }
        #[inline]
        pub fn add_kind(&mut self, kind: ColKind) {
            self.fbb_
                .push_slot::<ColKind>(ColDef::VT_KIND, kind, ColKind::value);
        }
        #[inline]
        pub fn add_logical_type(&mut self, logical_type: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ColDef::VT_LOGICAL_TYPE,
                logical_type,
            );
        }
        #[inline]
        pub fn add_logical_type_kind(&mut self, logical_type_kind: LogicalType) {
            self.fbb_.push_slot::<LogicalType>(
                ColDef::VT_LOGICAL_TYPE_KIND,
                logical_type_kind,
                LogicalType::unknown,
            );
        }
        #[inline]
        pub fn add_vector_element_type(
            &mut self,
            vector_element_type: ::flatbuffers::WIPOffset<&'b str>,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ColDef::VT_VECTOR_ELEMENT_TYPE,
                vector_element_type,
            );
        }
        #[inline]
        pub fn add_vector_dimension(&mut self, vector_dimension: u32) {
            self.fbb_
                .push_slot::<u32>(ColDef::VT_VECTOR_DIMENSION, vector_dimension, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ColDefBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ColDefBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ColDef<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ColDef<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ColDef");
            ds.field("name", &self.name());
            ds.field("kind", &self.kind());
            ds.field("logical_type", &self.logical_type());
            ds.field("logical_type_kind", &self.logical_type_kind());
            ds.field("vector_element_type", &self.vector_element_type());
            ds.field("vector_dimension", &self.vector_dimension());
            ds.finish()
        }
    }
    pub enum ColRefExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ColRefExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ColRefExpr<'a> {
        type Inner = ColRefExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ColRefExpr<'a> {
        pub const VT_IDX: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ColRefExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ColRefExprArgs,
        ) -> ::flatbuffers::WIPOffset<ColRefExpr<'bldr>> {
            let mut builder = ColRefExprBuilder::new(_fbb);
            builder.add_idx(args.idx);
            builder.finish()
        }

        #[inline]
        pub fn idx(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(ColRefExpr::VT_IDX, Some(0)).unwrap() }
        }
    }

    impl ::flatbuffers::Verifiable for ColRefExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("idx", Self::VT_IDX, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ColRefExprArgs {
        pub idx: u32,
    }
    impl<'a> Default for ColRefExprArgs {
        #[inline]
        fn default() -> Self {
            ColRefExprArgs { idx: 0 }
        }
    }

    pub struct ColRefExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ColRefExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_idx(&mut self, idx: u32) {
            self.fbb_.push_slot::<u32>(ColRefExpr::VT_IDX, idx, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ColRefExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ColRefExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ColRefExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ColRefExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ColRefExpr");
            ds.field("idx", &self.idx());
            ds.finish()
        }
    }
    pub enum PropAccessExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct PropAccessExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for PropAccessExpr<'a> {
        type Inner = PropAccessExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> PropAccessExpr<'a> {
        pub const VT_COL: ::flatbuffers::VOffsetT = 4;
        pub const VT_PROP: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            PropAccessExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args PropAccessExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<PropAccessExpr<'bldr>> {
            let mut builder = PropAccessExprBuilder::new(_fbb);
            if let Some(x) = args.prop {
                builder.add_prop(x);
            }
            builder.add_col(args.col);
            builder.finish()
        }

        #[inline]
        pub fn col(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(PropAccessExpr::VT_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn prop(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(PropAccessExpr::VT_PROP, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for PropAccessExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("col", Self::VT_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("prop", Self::VT_PROP, false)?
                .finish();
            Ok(())
        }
    }
    pub struct PropAccessExprArgs<'a> {
        pub col: u32,
        pub prop: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for PropAccessExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            PropAccessExprArgs { col: 0, prop: None }
        }
    }

    pub struct PropAccessExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PropAccessExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_col(&mut self, col: u32) {
            self.fbb_.push_slot::<u32>(PropAccessExpr::VT_COL, col, 0);
        }
        #[inline]
        pub fn add_prop(&mut self, prop: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(PropAccessExpr::VT_PROP, prop);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> PropAccessExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            PropAccessExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<PropAccessExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for PropAccessExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("PropAccessExpr");
            ds.field("col", &self.col());
            ds.field("prop", &self.prop());
            ds.finish()
        }
    }
    pub enum IntLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct IntLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for IntLiteralExpr<'a> {
        type Inner = IntLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> IntLiteralExpr<'a> {
        pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            IntLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args IntLiteralExprArgs,
        ) -> ::flatbuffers::WIPOffset<IntLiteralExpr<'bldr>> {
            let mut builder = IntLiteralExprBuilder::new(_fbb);
            builder.add_value(args.value);
            builder.finish()
        }

        #[inline]
        pub fn value(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i64>(IntLiteralExpr::VT_VALUE, Some(0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for IntLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<i64>("value", Self::VT_VALUE, false)?
                .finish();
            Ok(())
        }
    }
    pub struct IntLiteralExprArgs {
        pub value: i64,
    }
    impl<'a> Default for IntLiteralExprArgs {
        #[inline]
        fn default() -> Self {
            IntLiteralExprArgs { value: 0 }
        }
    }

    pub struct IntLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> IntLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_value(&mut self, value: i64) {
            self.fbb_
                .push_slot::<i64>(IntLiteralExpr::VT_VALUE, value, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> IntLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            IntLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<IntLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for IntLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("IntLiteralExpr");
            ds.field("value", &self.value());
            ds.finish()
        }
    }
    pub enum FloatLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct FloatLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for FloatLiteralExpr<'a> {
        type Inner = FloatLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> FloatLiteralExpr<'a> {
        pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            FloatLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args FloatLiteralExprArgs,
        ) -> ::flatbuffers::WIPOffset<FloatLiteralExpr<'bldr>> {
            let mut builder = FloatLiteralExprBuilder::new(_fbb);
            builder.add_value(args.value);
            builder.finish()
        }

        #[inline]
        pub fn value(&self) -> f64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<f64>(FloatLiteralExpr::VT_VALUE, Some(0.0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for FloatLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<f64>("value", Self::VT_VALUE, false)?
                .finish();
            Ok(())
        }
    }
    pub struct FloatLiteralExprArgs {
        pub value: f64,
    }
    impl<'a> Default for FloatLiteralExprArgs {
        #[inline]
        fn default() -> Self {
            FloatLiteralExprArgs { value: 0.0 }
        }
    }

    pub struct FloatLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> FloatLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_value(&mut self, value: f64) {
            self.fbb_
                .push_slot::<f64>(FloatLiteralExpr::VT_VALUE, value, 0.0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> FloatLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            FloatLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<FloatLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for FloatLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("FloatLiteralExpr");
            ds.field("value", &self.value());
            ds.finish()
        }
    }
    pub enum BoolLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct BoolLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for BoolLiteralExpr<'a> {
        type Inner = BoolLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> BoolLiteralExpr<'a> {
        pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            BoolLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args BoolLiteralExprArgs,
        ) -> ::flatbuffers::WIPOffset<BoolLiteralExpr<'bldr>> {
            let mut builder = BoolLiteralExprBuilder::new(_fbb);
            builder.add_value(args.value);
            builder.finish()
        }

        #[inline]
        pub fn value(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(BoolLiteralExpr::VT_VALUE, Some(false))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for BoolLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<bool>("value", Self::VT_VALUE, false)?
                .finish();
            Ok(())
        }
    }
    pub struct BoolLiteralExprArgs {
        pub value: bool,
    }
    impl<'a> Default for BoolLiteralExprArgs {
        #[inline]
        fn default() -> Self {
            BoolLiteralExprArgs { value: false }
        }
    }

    pub struct BoolLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> BoolLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_value(&mut self, value: bool) {
            self.fbb_
                .push_slot::<bool>(BoolLiteralExpr::VT_VALUE, value, false);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> BoolLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            BoolLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<BoolLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for BoolLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("BoolLiteralExpr");
            ds.field("value", &self.value());
            ds.finish()
        }
    }
    pub enum StringLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct StringLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for StringLiteralExpr<'a> {
        type Inner = StringLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> StringLiteralExpr<'a> {
        pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            StringLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args StringLiteralExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<StringLiteralExpr<'bldr>> {
            let mut builder = StringLiteralExprBuilder::new(_fbb);
            if let Some(x) = args.value {
                builder.add_value(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn value(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(StringLiteralExpr::VT_VALUE, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for StringLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "value",
                    Self::VT_VALUE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct StringLiteralExprArgs<'a> {
        pub value: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for StringLiteralExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            StringLiteralExprArgs { value: None }
        }
    }

    pub struct StringLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StringLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_value(&mut self, value: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                StringLiteralExpr::VT_VALUE,
                value,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> StringLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            StringLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<StringLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for StringLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("StringLiteralExpr");
            ds.field("value", &self.value());
            ds.finish()
        }
    }
    pub enum NullLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct NullLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for NullLiteralExpr<'a> {
        type Inner = NullLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> NullLiteralExpr<'a> {
        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            NullLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            _args: &'args NullLiteralExprArgs,
        ) -> ::flatbuffers::WIPOffset<NullLiteralExpr<'bldr>> {
            let mut builder = NullLiteralExprBuilder::new(_fbb);
            builder.finish()
        }
    }

    impl ::flatbuffers::Verifiable for NullLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?.finish();
            Ok(())
        }
    }
    pub struct NullLiteralExprArgs {}
    impl<'a> Default for NullLiteralExprArgs {
        #[inline]
        fn default() -> Self {
            NullLiteralExprArgs {}
        }
    }

    pub struct NullLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> NullLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> NullLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            NullLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<NullLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for NullLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("NullLiteralExpr");
            ds.finish()
        }
    }
    pub enum CmpExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct CmpExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for CmpExpr<'a> {
        type Inner = CmpExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> CmpExpr<'a> {
        pub const VT_OP: ::flatbuffers::VOffsetT = 4;
        pub const VT_LHS: ::flatbuffers::VOffsetT = 6;
        pub const VT_RHS: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            CmpExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args CmpExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<CmpExpr<'bldr>> {
            let mut builder = CmpExprBuilder::new(_fbb);
            if let Some(x) = args.rhs {
                builder.add_rhs(x);
            }
            if let Some(x) = args.lhs {
                builder.add_lhs(x);
            }
            builder.add_op(args.op);
            builder.finish()
        }

        #[inline]
        pub fn op(&self) -> CmpOp {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<CmpOp>(CmpExpr::VT_OP, Some(CmpOp::eq))
                    .unwrap()
            }
        }
        #[inline]
        pub fn lhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CmpExpr::VT_LHS, None)
            }
        }
        #[inline]
        pub fn rhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CmpExpr::VT_RHS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for CmpExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<CmpOp>("op", Self::VT_OP, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("lhs", Self::VT_LHS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("rhs", Self::VT_RHS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct CmpExprArgs<'a> {
        pub op: CmpOp,
        pub lhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub rhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for CmpExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            CmpExprArgs {
                op: CmpOp::eq,
                lhs: None,
                rhs: None,
            }
        }
    }

    pub struct CmpExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CmpExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_op(&mut self, op: CmpOp) {
            self.fbb_.push_slot::<CmpOp>(CmpExpr::VT_OP, op, CmpOp::eq);
        }
        #[inline]
        pub fn add_lhs(&mut self, lhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(CmpExpr::VT_LHS, lhs);
        }
        #[inline]
        pub fn add_rhs(&mut self, rhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(CmpExpr::VT_RHS, rhs);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> CmpExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            CmpExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<CmpExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for CmpExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("CmpExpr");
            ds.field("op", &self.op());
            ds.field("lhs", &self.lhs());
            ds.field("rhs", &self.rhs());
            ds.finish()
        }
    }
    pub enum AndExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct AndExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for AndExpr<'a> {
        type Inner = AndExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> AndExpr<'a> {
        pub const VT_LHS: ::flatbuffers::VOffsetT = 4;
        pub const VT_RHS: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            AndExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args AndExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<AndExpr<'bldr>> {
            let mut builder = AndExprBuilder::new(_fbb);
            if let Some(x) = args.rhs {
                builder.add_rhs(x);
            }
            if let Some(x) = args.lhs {
                builder.add_lhs(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn lhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(AndExpr::VT_LHS, None)
            }
        }
        #[inline]
        pub fn rhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(AndExpr::VT_RHS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for AndExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("lhs", Self::VT_LHS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("rhs", Self::VT_RHS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct AndExprArgs<'a> {
        pub lhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub rhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for AndExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            AndExprArgs {
                lhs: None,
                rhs: None,
            }
        }
    }

    pub struct AndExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AndExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_lhs(&mut self, lhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(AndExpr::VT_LHS, lhs);
        }
        #[inline]
        pub fn add_rhs(&mut self, rhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(AndExpr::VT_RHS, rhs);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> AndExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            AndExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<AndExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for AndExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("AndExpr");
            ds.field("lhs", &self.lhs());
            ds.field("rhs", &self.rhs());
            ds.finish()
        }
    }
    pub enum OrExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct OrExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for OrExpr<'a> {
        type Inner = OrExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> OrExpr<'a> {
        pub const VT_LHS: ::flatbuffers::VOffsetT = 4;
        pub const VT_RHS: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            OrExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args OrExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<OrExpr<'bldr>> {
            let mut builder = OrExprBuilder::new(_fbb);
            if let Some(x) = args.rhs {
                builder.add_rhs(x);
            }
            if let Some(x) = args.lhs {
                builder.add_lhs(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn lhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(OrExpr::VT_LHS, None)
            }
        }
        #[inline]
        pub fn rhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(OrExpr::VT_RHS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for OrExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("lhs", Self::VT_LHS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("rhs", Self::VT_RHS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct OrExprArgs<'a> {
        pub lhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub rhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for OrExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            OrExprArgs {
                lhs: None,
                rhs: None,
            }
        }
    }

    pub struct OrExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OrExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_lhs(&mut self, lhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(OrExpr::VT_LHS, lhs);
        }
        #[inline]
        pub fn add_rhs(&mut self, rhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(OrExpr::VT_RHS, rhs);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> OrExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            OrExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<OrExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for OrExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("OrExpr");
            ds.field("lhs", &self.lhs());
            ds.field("rhs", &self.rhs());
            ds.finish()
        }
    }
    pub enum NotExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct NotExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for NotExpr<'a> {
        type Inner = NotExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> NotExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            NotExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args NotExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<NotExpr<'bldr>> {
            let mut builder = NotExprBuilder::new(_fbb);
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(NotExpr::VT_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for NotExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .finish();
            Ok(())
        }
    }
    pub struct NotExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for NotExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            NotExprArgs { expr: None }
        }
    }

    pub struct NotExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> NotExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(NotExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> NotExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            NotExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<NotExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for NotExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("NotExpr");
            ds.field("expr", &self.expr());
            ds.finish()
        }
    }
    pub enum IsNullExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct IsNullExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for IsNullExpr<'a> {
        type Inner = IsNullExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> IsNullExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            IsNullExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args IsNullExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<IsNullExpr<'bldr>> {
            let mut builder = IsNullExprBuilder::new(_fbb);
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(IsNullExpr::VT_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for IsNullExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .finish();
            Ok(())
        }
    }
    pub struct IsNullExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for IsNullExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            IsNullExprArgs { expr: None }
        }
    }

    pub struct IsNullExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> IsNullExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(IsNullExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> IsNullExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            IsNullExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<IsNullExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for IsNullExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("IsNullExpr");
            ds.field("expr", &self.expr());
            ds.finish()
        }
    }
    pub enum IsNotNullExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct IsNotNullExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for IsNotNullExpr<'a> {
        type Inner = IsNotNullExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> IsNotNullExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            IsNotNullExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args IsNotNullExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<IsNotNullExpr<'bldr>> {
            let mut builder = IsNotNullExprBuilder::new(_fbb);
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(IsNotNullExpr::VT_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for IsNotNullExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .finish();
            Ok(())
        }
    }
    pub struct IsNotNullExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for IsNotNullExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            IsNotNullExprArgs { expr: None }
        }
    }

    pub struct IsNotNullExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> IsNotNullExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(IsNotNullExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> IsNotNullExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            IsNotNullExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<IsNotNullExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for IsNotNullExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("IsNotNullExpr");
            ds.field("expr", &self.expr());
            ds.finish()
        }
    }
    pub enum StartsWithExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct StartsWithExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for StartsWithExpr<'a> {
        type Inner = StartsWithExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> StartsWithExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;
        pub const VT_PATTERN: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            StartsWithExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args StartsWithExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<StartsWithExpr<'bldr>> {
            let mut builder = StartsWithExprBuilder::new(_fbb);
            if let Some(x) = args.pattern {
                builder.add_pattern(x);
            }
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(StartsWithExpr::VT_EXPR, None)
            }
        }
        #[inline]
        pub fn pattern(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(StartsWithExpr::VT_PATTERN, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for StartsWithExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "pattern",
                    Self::VT_PATTERN,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct StartsWithExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub pattern: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for StartsWithExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            StartsWithExprArgs {
                expr: None,
                pattern: None,
            }
        }
    }

    pub struct StartsWithExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StartsWithExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(StartsWithExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn add_pattern(&mut self, pattern: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                StartsWithExpr::VT_PATTERN,
                pattern,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> StartsWithExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            StartsWithExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<StartsWithExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for StartsWithExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("StartsWithExpr");
            ds.field("expr", &self.expr());
            ds.field("pattern", &self.pattern());
            ds.finish()
        }
    }
    pub enum EndsWithExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct EndsWithExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for EndsWithExpr<'a> {
        type Inner = EndsWithExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> EndsWithExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;
        pub const VT_PATTERN: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            EndsWithExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args EndsWithExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<EndsWithExpr<'bldr>> {
            let mut builder = EndsWithExprBuilder::new(_fbb);
            if let Some(x) = args.pattern {
                builder.add_pattern(x);
            }
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(EndsWithExpr::VT_EXPR, None)
            }
        }
        #[inline]
        pub fn pattern(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(EndsWithExpr::VT_PATTERN, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for EndsWithExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "pattern",
                    Self::VT_PATTERN,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct EndsWithExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub pattern: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for EndsWithExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            EndsWithExprArgs {
                expr: None,
                pattern: None,
            }
        }
    }

    pub struct EndsWithExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> EndsWithExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(EndsWithExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn add_pattern(&mut self, pattern: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(EndsWithExpr::VT_PATTERN, pattern);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> EndsWithExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            EndsWithExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<EndsWithExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for EndsWithExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("EndsWithExpr");
            ds.field("expr", &self.expr());
            ds.field("pattern", &self.pattern());
            ds.finish()
        }
    }
    pub enum ContainsExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ContainsExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ContainsExpr<'a> {
        type Inner = ContainsExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ContainsExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;
        pub const VT_PATTERN: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ContainsExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ContainsExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ContainsExpr<'bldr>> {
            let mut builder = ContainsExprBuilder::new(_fbb);
            if let Some(x) = args.pattern {
                builder.add_pattern(x);
            }
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(ContainsExpr::VT_EXPR, None)
            }
        }
        #[inline]
        pub fn pattern(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ContainsExpr::VT_PATTERN, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ContainsExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "pattern",
                    Self::VT_PATTERN,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ContainsExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub pattern: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ContainsExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            ContainsExprArgs {
                expr: None,
                pattern: None,
            }
        }
    }

    pub struct ContainsExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContainsExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(ContainsExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn add_pattern(&mut self, pattern: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContainsExpr::VT_PATTERN, pattern);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ContainsExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ContainsExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContainsExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ContainsExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ContainsExpr");
            ds.field("expr", &self.expr());
            ds.field("pattern", &self.pattern());
            ds.finish()
        }
    }
    pub enum InExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct InExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for InExpr<'a> {
        type Inner = InExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> InExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;
        pub const VT_ITEMS: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            InExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args InExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<InExpr<'bldr>> {
            let mut builder = InExprBuilder::new(_fbb);
            if let Some(x) = args.items {
                builder.add_items(x);
            }
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(InExpr::VT_EXPR, None)
            }
        }
        #[inline]
        pub fn items(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>(InExpr::VT_ITEMS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for InExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>("items", Self::VT_ITEMS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct InExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub items: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>,
            >,
        >,
    }
    impl<'a> Default for InExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            InExprArgs {
                expr: None,
                items: None,
            }
        }
    }

    pub struct InExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> InExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(InExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn add_items(
            &mut self,
            items: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Expr<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(InExpr::VT_ITEMS, items);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> InExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            InExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<InExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for InExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("InExpr");
            ds.field("expr", &self.expr());
            ds.field("items", &self.items());
            ds.finish()
        }
    }
    pub enum ListLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ListLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ListLiteralExpr<'a> {
        type Inner = ListLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ListLiteralExpr<'a> {
        pub const VT_ITEMS: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ListLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ListLiteralExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ListLiteralExpr<'bldr>> {
            let mut builder = ListLiteralExprBuilder::new(_fbb);
            if let Some(x) = args.items {
                builder.add_items(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn items(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>(ListLiteralExpr::VT_ITEMS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ListLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>("items", Self::VT_ITEMS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ListLiteralExprArgs<'a> {
        pub items: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>,
            >,
        >,
    }
    impl<'a> Default for ListLiteralExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            ListLiteralExprArgs { items: None }
        }
    }

    pub struct ListLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ListLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_items(
            &mut self,
            items: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Expr<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ListLiteralExpr::VT_ITEMS, items);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ListLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ListLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ListLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ListLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ListLiteralExpr");
            ds.field("items", &self.items());
            ds.finish()
        }
    }
    pub enum MapEntryExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct MapEntryExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for MapEntryExpr<'a> {
        type Inner = MapEntryExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> MapEntryExpr<'a> {
        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
        pub const VT_VALUE: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            MapEntryExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args MapEntryExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<MapEntryExpr<'bldr>> {
            let mut builder = MapEntryExprBuilder::new(_fbb);
            if let Some(x) = args.value {
                builder.add_value(x);
            }
            if let Some(x) = args.key {
                builder.add_key(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn key(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(MapEntryExpr::VT_KEY, None)
            }
        }
        #[inline]
        pub fn value(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(MapEntryExpr::VT_VALUE, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for MapEntryExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "value",
                    Self::VT_VALUE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct MapEntryExprArgs<'a> {
        pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub value: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for MapEntryExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            MapEntryExprArgs {
                key: None,
                value: None,
            }
        }
    }

    pub struct MapEntryExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MapEntryExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(MapEntryExpr::VT_KEY, key);
        }
        #[inline]
        pub fn add_value(&mut self, value: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(MapEntryExpr::VT_VALUE, value);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> MapEntryExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            MapEntryExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<MapEntryExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for MapEntryExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("MapEntryExpr");
            ds.field("key", &self.key());
            ds.field("value", &self.value());
            ds.finish()
        }
    }
    pub enum MapLiteralExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct MapLiteralExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for MapLiteralExpr<'a> {
        type Inner = MapLiteralExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> MapLiteralExpr<'a> {
        pub const VT_ENTRIES: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            MapLiteralExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args MapLiteralExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<MapLiteralExpr<'bldr>> {
            let mut builder = MapLiteralExprBuilder::new(_fbb);
            if let Some(x) = args.entries {
                builder.add_entries(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn entries(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MapEntryExpr<'a>>>>
        {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MapEntryExpr>>,
                >>(MapLiteralExpr::VT_ENTRIES, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for MapLiteralExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MapEntryExpr>>,
                >>("entries", Self::VT_ENTRIES, false)?
                .finish();
            Ok(())
        }
    }
    pub struct MapLiteralExprArgs<'a> {
        pub entries: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MapEntryExpr<'a>>>,
            >,
        >,
    }
    impl<'a> Default for MapLiteralExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            MapLiteralExprArgs { entries: None }
        }
    }

    pub struct MapLiteralExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MapLiteralExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_entries(
            &mut self,
            entries: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<MapEntryExpr<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                MapLiteralExpr::VT_ENTRIES,
                entries,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> MapLiteralExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            MapLiteralExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<MapLiteralExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for MapLiteralExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("MapLiteralExpr");
            ds.field("entries", &self.entries());
            ds.finish()
        }
    }
    pub enum ExistsExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ExistsExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ExistsExpr<'a> {
        type Inner = ExistsExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ExistsExpr<'a> {
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ExistsExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ExistsExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ExistsExpr<'bldr>> {
            let mut builder = ExistsExprBuilder::new(_fbb);
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(ExistsExpr::VT_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ExistsExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ExistsExprArgs<'a> {
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for ExistsExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            ExistsExprArgs { expr: None }
        }
    }

    pub struct ExistsExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ExistsExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(ExistsExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ExistsExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ExistsExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ExistsExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ExistsExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ExistsExpr");
            ds.field("expr", &self.expr());
            ds.finish()
        }
    }
    pub enum ListComprehensionExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ListComprehensionExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ListComprehensionExpr<'a> {
        type Inner = ListComprehensionExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ListComprehensionExpr<'a> {
        pub const VT_LIST: ::flatbuffers::VOffsetT = 4;
        pub const VT_VAR: ::flatbuffers::VOffsetT = 6;
        pub const VT_PREDICATE: ::flatbuffers::VOffsetT = 8;
        pub const VT_MAP: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ListComprehensionExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ListComprehensionExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ListComprehensionExpr<'bldr>> {
            let mut builder = ListComprehensionExprBuilder::new(_fbb);
            if let Some(x) = args.map {
                builder.add_map(x);
            }
            if let Some(x) = args.predicate {
                builder.add_predicate(x);
            }
            if let Some(x) = args.var {
                builder.add_var(x);
            }
            if let Some(x) = args.list {
                builder.add_list(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn list(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<Expr>>(
                    ListComprehensionExpr::VT_LIST,
                    None,
                )
            }
        }
        #[inline]
        pub fn var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                    ListComprehensionExpr::VT_VAR,
                    None,
                )
            }
        }
        #[inline]
        pub fn predicate(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<Expr>>(
                    ListComprehensionExpr::VT_PREDICATE,
                    None,
                )
            }
        }
        #[inline]
        pub fn map(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<Expr>>(
                    ListComprehensionExpr::VT_MAP,
                    None,
                )
            }
        }
    }

    impl ::flatbuffers::Verifiable for ListComprehensionExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("list", Self::VT_LIST, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("var", Self::VT_VAR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "predicate",
                    Self::VT_PREDICATE,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("map", Self::VT_MAP, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ListComprehensionExprArgs<'a> {
        pub list: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub predicate: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub map: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for ListComprehensionExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            ListComprehensionExprArgs {
                list: None,
                var: None,
                predicate: None,
                map: None,
            }
        }
    }

    pub struct ListComprehensionExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ListComprehensionExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_list(&mut self, list: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    ListComprehensionExpr::VT_LIST,
                    list,
                );
        }
        #[inline]
        pub fn add_var(&mut self, var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ListComprehensionExpr::VT_VAR,
                var,
            );
        }
        #[inline]
        pub fn add_predicate(&mut self, predicate: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    ListComprehensionExpr::VT_PREDICATE,
                    predicate,
                );
        }
        #[inline]
        pub fn add_map(&mut self, map: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    ListComprehensionExpr::VT_MAP,
                    map,
                );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ListComprehensionExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ListComprehensionExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ListComprehensionExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ListComprehensionExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ListComprehensionExpr");
            ds.field("list", &self.list());
            ds.field("var", &self.var());
            ds.field("predicate", &self.predicate());
            ds.field("map", &self.map());
            ds.finish()
        }
    }
    pub enum AggExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct AggExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for AggExpr<'a> {
        type Inner = AggExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> AggExpr<'a> {
        pub const VT_FN_: ::flatbuffers::VOffsetT = 4;
        pub const VT_EXPR: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            AggExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args AggExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<AggExpr<'bldr>> {
            let mut builder = AggExprBuilder::new(_fbb);
            if let Some(x) = args.expr {
                builder.add_expr(x);
            }
            builder.add_fn_(args.fn_);
            builder.finish()
        }

        #[inline]
        pub fn fn_(&self) -> AggFn {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<AggFn>(AggExpr::VT_FN_, Some(AggFn::count))
                    .unwrap()
            }
        }
        #[inline]
        pub fn expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(AggExpr::VT_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for AggExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<AggFn>("fn_", Self::VT_FN_, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("expr", Self::VT_EXPR, false)?
                .finish();
            Ok(())
        }
    }
    pub struct AggExprArgs<'a> {
        pub fn_: AggFn,
        pub expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for AggExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            AggExprArgs {
                fn_: AggFn::count,
                expr: None,
            }
        }
    }

    pub struct AggExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AggExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_fn_(&mut self, fn_: AggFn) {
            self.fbb_
                .push_slot::<AggFn>(AggExpr::VT_FN_, fn_, AggFn::count);
        }
        #[inline]
        pub fn add_expr(&mut self, expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(AggExpr::VT_EXPR, expr);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> AggExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            AggExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<AggExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for AggExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("AggExpr");
            ds.field("fn_", &self.fn_());
            ds.field("expr", &self.expr());
            ds.finish()
        }
    }
    pub enum ArithExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ArithExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ArithExpr<'a> {
        type Inner = ArithExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ArithExpr<'a> {
        pub const VT_OP: ::flatbuffers::VOffsetT = 4;
        pub const VT_LHS: ::flatbuffers::VOffsetT = 6;
        pub const VT_RHS: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ArithExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ArithExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ArithExpr<'bldr>> {
            let mut builder = ArithExprBuilder::new(_fbb);
            if let Some(x) = args.rhs {
                builder.add_rhs(x);
            }
            if let Some(x) = args.lhs {
                builder.add_lhs(x);
            }
            builder.add_op(args.op);
            builder.finish()
        }

        #[inline]
        pub fn op(&self) -> ArithOp {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ArithOp>(ArithExpr::VT_OP, Some(ArithOp::add))
                    .unwrap()
            }
        }
        #[inline]
        pub fn lhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(ArithExpr::VT_LHS, None)
            }
        }
        #[inline]
        pub fn rhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(ArithExpr::VT_RHS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ArithExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<ArithOp>("op", Self::VT_OP, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("lhs", Self::VT_LHS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("rhs", Self::VT_RHS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ArithExprArgs<'a> {
        pub op: ArithOp,
        pub lhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub rhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for ArithExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            ArithExprArgs {
                op: ArithOp::add,
                lhs: None,
                rhs: None,
            }
        }
    }

    pub struct ArithExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArithExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_op(&mut self, op: ArithOp) {
            self.fbb_
                .push_slot::<ArithOp>(ArithExpr::VT_OP, op, ArithOp::add);
        }
        #[inline]
        pub fn add_lhs(&mut self, lhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(ArithExpr::VT_LHS, lhs);
        }
        #[inline]
        pub fn add_rhs(&mut self, rhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(ArithExpr::VT_RHS, rhs);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ArithExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ArithExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ArithExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ArithExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ArithExpr");
            ds.field("op", &self.op());
            ds.field("lhs", &self.lhs());
            ds.field("rhs", &self.rhs());
            ds.finish()
        }
    }
    pub enum ParamExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ParamExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ParamExpr<'a> {
        type Inner = ParamExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ParamExpr<'a> {
        pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
        pub const VT_EXPECTED_TYPE: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ParamExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ParamExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ParamExpr<'bldr>> {
            let mut builder = ParamExprBuilder::new(_fbb);
            if let Some(x) = args.expected_type {
                builder.add_expected_type(x);
            }
            if let Some(x) = args.name {
                builder.add_name(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn name(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ParamExpr::VT_NAME, None)
            }
        }
        #[inline]
        pub fn expected_type(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ParamExpr::VT_EXPECTED_TYPE, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ParamExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "expected_type",
                    Self::VT_EXPECTED_TYPE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ParamExprArgs<'a> {
        pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub expected_type: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ParamExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            ParamExprArgs {
                name: None,
                expected_type: None,
            }
        }
    }

    pub struct ParamExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ParamExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ParamExpr::VT_NAME, name);
        }
        #[inline]
        pub fn add_expected_type(&mut self, expected_type: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ParamExpr::VT_EXPECTED_TYPE,
                expected_type,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ParamExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ParamExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ParamExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ParamExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ParamExpr");
            ds.field("name", &self.name());
            ds.field("expected_type", &self.expected_type());
            ds.finish()
        }
    }
    pub enum CaseArmOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct CaseArm<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for CaseArm<'a> {
        type Inner = CaseArm<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> CaseArm<'a> {
        pub const VT_WHEN_EXPR: ::flatbuffers::VOffsetT = 4;
        pub const VT_THEN_EXPR: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            CaseArm { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args CaseArmArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<CaseArm<'bldr>> {
            let mut builder = CaseArmBuilder::new(_fbb);
            if let Some(x) = args.then_expr {
                builder.add_then_expr(x);
            }
            if let Some(x) = args.when_expr {
                builder.add_when_expr(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn when_expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CaseArm::VT_WHEN_EXPR, None)
            }
        }
        #[inline]
        pub fn then_expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CaseArm::VT_THEN_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for CaseArm<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "when_expr",
                    Self::VT_WHEN_EXPR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "then_expr",
                    Self::VT_THEN_EXPR,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct CaseArmArgs<'a> {
        pub when_expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub then_expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for CaseArmArgs<'a> {
        #[inline]
        fn default() -> Self {
            CaseArmArgs {
                when_expr: None,
                then_expr: None,
            }
        }
    }

    pub struct CaseArmBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CaseArmBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_when_expr(&mut self, when_expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    CaseArm::VT_WHEN_EXPR,
                    when_expr,
                );
        }
        #[inline]
        pub fn add_then_expr(&mut self, then_expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    CaseArm::VT_THEN_EXPR,
                    then_expr,
                );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> CaseArmBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            CaseArmBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<CaseArm<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for CaseArm<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("CaseArm");
            ds.field("when_expr", &self.when_expr());
            ds.field("then_expr", &self.then_expr());
            ds.finish()
        }
    }
    pub enum CaseExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct CaseExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for CaseExpr<'a> {
        type Inner = CaseExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> CaseExpr<'a> {
        pub const VT_ARMS: ::flatbuffers::VOffsetT = 4;
        pub const VT_ELSE_EXPR: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            CaseExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args CaseExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<CaseExpr<'bldr>> {
            let mut builder = CaseExprBuilder::new(_fbb);
            if let Some(x) = args.else_expr {
                builder.add_else_expr(x);
            }
            if let Some(x) = args.arms {
                builder.add_arms(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn arms(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CaseArm<'a>>>>
        {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CaseArm>>,
                >>(CaseExpr::VT_ARMS, None)
            }
        }
        #[inline]
        pub fn else_expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CaseExpr::VT_ELSE_EXPR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for CaseExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<CaseArm>>,
                >>("arms", Self::VT_ARMS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "else_expr",
                    Self::VT_ELSE_EXPR,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct CaseExprArgs<'a> {
        pub arms: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CaseArm<'a>>>,
            >,
        >,
        pub else_expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for CaseExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            CaseExprArgs {
                arms: None,
                else_expr: None,
            }
        }
    }

    pub struct CaseExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CaseExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_arms(
            &mut self,
            arms: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<CaseArm<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(CaseExpr::VT_ARMS, arms);
        }
        #[inline]
        pub fn add_else_expr(&mut self, else_expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    CaseExpr::VT_ELSE_EXPR,
                    else_expr,
                );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> CaseExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            CaseExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<CaseExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for CaseExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("CaseExpr");
            ds.field("arms", &self.arms());
            ds.field("else_expr", &self.else_expr());
            ds.finish()
        }
    }
    pub enum VectorSimilarityExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct VectorSimilarityExpr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for VectorSimilarityExpr<'a> {
        type Inner = VectorSimilarityExpr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> VectorSimilarityExpr<'a> {
        pub const VT_METRIC: ::flatbuffers::VOffsetT = 4;
        pub const VT_LHS: ::flatbuffers::VOffsetT = 6;
        pub const VT_RHS: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            VectorSimilarityExpr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args VectorSimilarityExprArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<VectorSimilarityExpr<'bldr>> {
            let mut builder = VectorSimilarityExprBuilder::new(_fbb);
            if let Some(x) = args.rhs {
                builder.add_rhs(x);
            }
            if let Some(x) = args.lhs {
                builder.add_lhs(x);
            }
            builder.add_metric(args.metric);
            builder.finish()
        }

        #[inline]
        pub fn metric(&self) -> VectorMetric {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<VectorMetric>(
                        VectorSimilarityExpr::VT_METRIC,
                        Some(VectorMetric::cosine),
                    )
                    .unwrap()
            }
        }
        #[inline]
        pub fn lhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(VectorSimilarityExpr::VT_LHS, None)
            }
        }
        #[inline]
        pub fn rhs(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(VectorSimilarityExpr::VT_RHS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for VectorSimilarityExpr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<VectorMetric>("metric", Self::VT_METRIC, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("lhs", Self::VT_LHS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>("rhs", Self::VT_RHS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct VectorSimilarityExprArgs<'a> {
        pub metric: VectorMetric,
        pub lhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub rhs: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for VectorSimilarityExprArgs<'a> {
        #[inline]
        fn default() -> Self {
            VectorSimilarityExprArgs {
                metric: VectorMetric::cosine,
                lhs: None,
                rhs: None,
            }
        }
    }

    pub struct VectorSimilarityExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> VectorSimilarityExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_metric(&mut self, metric: VectorMetric) {
            self.fbb_.push_slot::<VectorMetric>(
                VectorSimilarityExpr::VT_METRIC,
                metric,
                VectorMetric::cosine,
            );
        }
        #[inline]
        pub fn add_lhs(&mut self, lhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    VectorSimilarityExpr::VT_LHS,
                    lhs,
                );
        }
        #[inline]
        pub fn add_rhs(&mut self, rhs: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    VectorSimilarityExpr::VT_RHS,
                    rhs,
                );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> VectorSimilarityExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            VectorSimilarityExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<VectorSimilarityExpr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for VectorSimilarityExpr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("VectorSimilarityExpr");
            ds.field("metric", &self.metric());
            ds.field("lhs", &self.lhs());
            ds.field("rhs", &self.rhs());
            ds.finish()
        }
    }
    pub enum ExprOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct Expr<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for Expr<'a> {
        type Inner = Expr<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> Expr<'a> {
        pub const VT_NODE_TYPE: ::flatbuffers::VOffsetT = 4;
        pub const VT_NODE: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            Expr { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ExprArgs,
        ) -> ::flatbuffers::WIPOffset<Expr<'bldr>> {
            let mut builder = ExprBuilder::new(_fbb);
            if let Some(x) = args.node {
                builder.add_node(x);
            }
            builder.add_node_type(args.node_type);
            builder.finish()
        }

        #[inline]
        pub fn node_type(&self) -> ExprNode {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ExprNode>(Expr::VT_NODE_TYPE, Some(ExprNode::NONE))
                    .unwrap()
            }
        }
        #[inline]
        pub fn node(&self) -> Option<::flatbuffers::Table<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                        Expr::VT_NODE,
                        None,
                    )
            }
        }
        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_col_ref_expr(&self) -> Option<ColRefExpr<'a>> {
            if self.node_type() == ExprNode::ColRefExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ColRefExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_prop_access_expr(&self) -> Option<PropAccessExpr<'a>> {
            if self.node_type() == ExprNode::PropAccessExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { PropAccessExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_int_literal_expr(&self) -> Option<IntLiteralExpr<'a>> {
            if self.node_type() == ExprNode::IntLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { IntLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_float_literal_expr(&self) -> Option<FloatLiteralExpr<'a>> {
            if self.node_type() == ExprNode::FloatLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { FloatLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_bool_literal_expr(&self) -> Option<BoolLiteralExpr<'a>> {
            if self.node_type() == ExprNode::BoolLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { BoolLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_string_literal_expr(&self) -> Option<StringLiteralExpr<'a>> {
            if self.node_type() == ExprNode::StringLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { StringLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_null_literal_expr(&self) -> Option<NullLiteralExpr<'a>> {
            if self.node_type() == ExprNode::NullLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { NullLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_cmp_expr(&self) -> Option<CmpExpr<'a>> {
            if self.node_type() == ExprNode::CmpExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { CmpExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_and_expr(&self) -> Option<AndExpr<'a>> {
            if self.node_type() == ExprNode::AndExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { AndExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_or_expr(&self) -> Option<OrExpr<'a>> {
            if self.node_type() == ExprNode::OrExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { OrExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_not_expr(&self) -> Option<NotExpr<'a>> {
            if self.node_type() == ExprNode::NotExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { NotExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_is_null_expr(&self) -> Option<IsNullExpr<'a>> {
            if self.node_type() == ExprNode::IsNullExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { IsNullExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_is_not_null_expr(&self) -> Option<IsNotNullExpr<'a>> {
            if self.node_type() == ExprNode::IsNotNullExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { IsNotNullExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_starts_with_expr(&self) -> Option<StartsWithExpr<'a>> {
            if self.node_type() == ExprNode::StartsWithExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { StartsWithExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_ends_with_expr(&self) -> Option<EndsWithExpr<'a>> {
            if self.node_type() == ExprNode::EndsWithExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { EndsWithExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_contains_expr(&self) -> Option<ContainsExpr<'a>> {
            if self.node_type() == ExprNode::ContainsExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ContainsExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_in_expr(&self) -> Option<InExpr<'a>> {
            if self.node_type() == ExprNode::InExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { InExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_list_literal_expr(&self) -> Option<ListLiteralExpr<'a>> {
            if self.node_type() == ExprNode::ListLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ListLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_map_literal_expr(&self) -> Option<MapLiteralExpr<'a>> {
            if self.node_type() == ExprNode::MapLiteralExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { MapLiteralExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_exists_expr(&self) -> Option<ExistsExpr<'a>> {
            if self.node_type() == ExprNode::ExistsExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ExistsExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_list_comprehension_expr(&self) -> Option<ListComprehensionExpr<'a>> {
            if self.node_type() == ExprNode::ListComprehensionExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ListComprehensionExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_agg_expr(&self) -> Option<AggExpr<'a>> {
            if self.node_type() == ExprNode::AggExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { AggExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_arith_expr(&self) -> Option<ArithExpr<'a>> {
            if self.node_type() == ExprNode::ArithExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ArithExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_param_expr(&self) -> Option<ParamExpr<'a>> {
            if self.node_type() == ExprNode::ParamExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ParamExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_case_expr(&self) -> Option<CaseExpr<'a>> {
            if self.node_type() == ExprNode::CaseExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { CaseExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_vector_similarity_expr(&self) -> Option<VectorSimilarityExpr<'a>> {
            if self.node_type() == ExprNode::VectorSimilarityExpr {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { VectorSimilarityExpr::init_from_table(t) }
                })
            } else {
                None
            }
        }
    }

    impl ::flatbuffers::Verifiable for Expr<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
     .visit_union::<ExprNode, _>("node_type", Self::VT_NODE_TYPE, "node", Self::VT_NODE, false, |key, v, pos| {
        match key {
          ExprNode::ColRefExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ColRefExpr>>("ExprNode::ColRefExpr", pos),
          ExprNode::PropAccessExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<PropAccessExpr>>("ExprNode::PropAccessExpr", pos),
          ExprNode::IntLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<IntLiteralExpr>>("ExprNode::IntLiteralExpr", pos),
          ExprNode::FloatLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<FloatLiteralExpr>>("ExprNode::FloatLiteralExpr", pos),
          ExprNode::BoolLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<BoolLiteralExpr>>("ExprNode::BoolLiteralExpr", pos),
          ExprNode::StringLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StringLiteralExpr>>("ExprNode::StringLiteralExpr", pos),
          ExprNode::NullLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<NullLiteralExpr>>("ExprNode::NullLiteralExpr", pos),
          ExprNode::CmpExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CmpExpr>>("ExprNode::CmpExpr", pos),
          ExprNode::AndExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AndExpr>>("ExprNode::AndExpr", pos),
          ExprNode::OrExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<OrExpr>>("ExprNode::OrExpr", pos),
          ExprNode::NotExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<NotExpr>>("ExprNode::NotExpr", pos),
          ExprNode::IsNullExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<IsNullExpr>>("ExprNode::IsNullExpr", pos),
          ExprNode::IsNotNullExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<IsNotNullExpr>>("ExprNode::IsNotNullExpr", pos),
          ExprNode::StartsWithExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StartsWithExpr>>("ExprNode::StartsWithExpr", pos),
          ExprNode::EndsWithExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<EndsWithExpr>>("ExprNode::EndsWithExpr", pos),
          ExprNode::ContainsExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ContainsExpr>>("ExprNode::ContainsExpr", pos),
          ExprNode::InExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<InExpr>>("ExprNode::InExpr", pos),
          ExprNode::ListLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ListLiteralExpr>>("ExprNode::ListLiteralExpr", pos),
          ExprNode::MapLiteralExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MapLiteralExpr>>("ExprNode::MapLiteralExpr", pos),
          ExprNode::ExistsExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ExistsExpr>>("ExprNode::ExistsExpr", pos),
          ExprNode::ListComprehensionExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ListComprehensionExpr>>("ExprNode::ListComprehensionExpr", pos),
          ExprNode::AggExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AggExpr>>("ExprNode::AggExpr", pos),
          ExprNode::ArithExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ArithExpr>>("ExprNode::ArithExpr", pos),
          ExprNode::ParamExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ParamExpr>>("ExprNode::ParamExpr", pos),
          ExprNode::CaseExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CaseExpr>>("ExprNode::CaseExpr", pos),
          ExprNode::VectorSimilarityExpr => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<VectorSimilarityExpr>>("ExprNode::VectorSimilarityExpr", pos),
          _ => Ok(()),
        }
     })?
     .finish();
            Ok(())
        }
    }
    pub struct ExprArgs {
        pub node_type: ExprNode,
        pub node: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
    }
    impl<'a> Default for ExprArgs {
        #[inline]
        fn default() -> Self {
            ExprArgs {
                node_type: ExprNode::NONE,
                node: None,
            }
        }
    }

    pub struct ExprBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ExprBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_node_type(&mut self, node_type: ExprNode) {
            self.fbb_
                .push_slot::<ExprNode>(Expr::VT_NODE_TYPE, node_type, ExprNode::NONE);
        }
        #[inline]
        pub fn add_node(&mut self, node: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Expr::VT_NODE, node);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ExprBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ExprBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<Expr<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for Expr<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("Expr");
            ds.field("node_type", &self.node_type());
            match self.node_type() {
                ExprNode::ColRefExpr => {
                    if let Some(x) = self.node_as_col_ref_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::PropAccessExpr => {
                    if let Some(x) = self.node_as_prop_access_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::IntLiteralExpr => {
                    if let Some(x) = self.node_as_int_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::FloatLiteralExpr => {
                    if let Some(x) = self.node_as_float_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::BoolLiteralExpr => {
                    if let Some(x) = self.node_as_bool_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::StringLiteralExpr => {
                    if let Some(x) = self.node_as_string_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::NullLiteralExpr => {
                    if let Some(x) = self.node_as_null_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::CmpExpr => {
                    if let Some(x) = self.node_as_cmp_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::AndExpr => {
                    if let Some(x) = self.node_as_and_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::OrExpr => {
                    if let Some(x) = self.node_as_or_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::NotExpr => {
                    if let Some(x) = self.node_as_not_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::IsNullExpr => {
                    if let Some(x) = self.node_as_is_null_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::IsNotNullExpr => {
                    if let Some(x) = self.node_as_is_not_null_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::StartsWithExpr => {
                    if let Some(x) = self.node_as_starts_with_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::EndsWithExpr => {
                    if let Some(x) = self.node_as_ends_with_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::ContainsExpr => {
                    if let Some(x) = self.node_as_contains_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::InExpr => {
                    if let Some(x) = self.node_as_in_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::ListLiteralExpr => {
                    if let Some(x) = self.node_as_list_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::MapLiteralExpr => {
                    if let Some(x) = self.node_as_map_literal_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::ExistsExpr => {
                    if let Some(x) = self.node_as_exists_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::ListComprehensionExpr => {
                    if let Some(x) = self.node_as_list_comprehension_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::AggExpr => {
                    if let Some(x) = self.node_as_agg_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::ArithExpr => {
                    if let Some(x) = self.node_as_arith_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::ParamExpr => {
                    if let Some(x) = self.node_as_param_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::CaseExpr => {
                    if let Some(x) = self.node_as_case_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                ExprNode::VectorSimilarityExpr => {
                    if let Some(x) = self.node_as_vector_similarity_expr() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                _ => {
                    let x: Option<()> = None;
                    ds.field("node", &x)
                }
            };
            ds.finish()
        }
    }
    pub enum ScanNodesOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ScanNodesOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ScanNodesOp<'a> {
        type Inner = ScanNodesOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ScanNodesOp<'a> {
        pub const VT_LABELS: ::flatbuffers::VOffsetT = 4;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 6;
        pub const VT_MUST_LABELS: ::flatbuffers::VOffsetT = 8;
        pub const VT_FORBIDDEN_LABELS: ::flatbuffers::VOffsetT = 10;
        pub const VT_EST_ROWS: ::flatbuffers::VOffsetT = 12;
        pub const VT_SELECTIVITY: ::flatbuffers::VOffsetT = 14;
        pub const VT_GRAPH_REF: ::flatbuffers::VOffsetT = 16;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ScanNodesOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ScanNodesOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ScanNodesOp<'bldr>> {
            let mut builder = ScanNodesOpBuilder::new(_fbb);
            builder.add_selectivity(args.selectivity);
            builder.add_est_rows(args.est_rows);
            if let Some(x) = args.graph_ref {
                builder.add_graph_ref(x);
            }
            if let Some(x) = args.forbidden_labels {
                builder.add_forbidden_labels(x);
            }
            if let Some(x) = args.must_labels {
                builder.add_must_labels(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.labels {
                builder.add_labels(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ScanNodesOp::VT_LABELS, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(ScanNodesOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn must_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ScanNodesOp::VT_MUST_LABELS, None)
            }
        }
        #[inline]
        pub fn forbidden_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ScanNodesOp::VT_FORBIDDEN_LABELS, None)
            }
        }
        #[inline]
        pub fn est_rows(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i64>(ScanNodesOp::VT_EST_ROWS, Some(-1))
                    .unwrap()
            }
        }
        #[inline]
        pub fn selectivity(&self) -> f64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<f64>(ScanNodesOp::VT_SELECTIVITY, Some(1.0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn graph_ref(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ScanNodesOp::VT_GRAPH_REF, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ScanNodesOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("labels", Self::VT_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("must_labels", Self::VT_MUST_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("forbidden_labels", Self::VT_FORBIDDEN_LABELS, false)?
                .visit_field::<i64>("est_rows", Self::VT_EST_ROWS, false)?
                .visit_field::<f64>("selectivity", Self::VT_SELECTIVITY, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "graph_ref",
                    Self::VT_GRAPH_REF,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ScanNodesOpArgs<'a> {
        pub labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub must_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub forbidden_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub est_rows: i64,
        pub selectivity: f64,
        pub graph_ref: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ScanNodesOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            ScanNodesOpArgs {
                labels: None,
                schema: None,
                must_labels: None,
                forbidden_labels: None,
                est_rows: -1,
                selectivity: 1.0,
                graph_ref: None,
            }
        }
    }

    pub struct ScanNodesOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ScanNodesOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_labels(
            &mut self,
            labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ScanNodesOp::VT_LABELS, labels);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ScanNodesOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_must_labels(
            &mut self,
            must_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ScanNodesOp::VT_MUST_LABELS,
                must_labels,
            );
        }
        #[inline]
        pub fn add_forbidden_labels(
            &mut self,
            forbidden_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ScanNodesOp::VT_FORBIDDEN_LABELS,
                forbidden_labels,
            );
        }
        #[inline]
        pub fn add_est_rows(&mut self, est_rows: i64) {
            self.fbb_
                .push_slot::<i64>(ScanNodesOp::VT_EST_ROWS, est_rows, -1);
        }
        #[inline]
        pub fn add_selectivity(&mut self, selectivity: f64) {
            self.fbb_
                .push_slot::<f64>(ScanNodesOp::VT_SELECTIVITY, selectivity, 1.0);
        }
        #[inline]
        pub fn add_graph_ref(&mut self, graph_ref: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ScanNodesOp::VT_GRAPH_REF,
                graph_ref,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ScanNodesOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ScanNodesOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ScanNodesOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ScanNodesOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ScanNodesOp");
            ds.field("labels", &self.labels());
            ds.field("schema", &self.schema());
            ds.field("must_labels", &self.must_labels());
            ds.field("forbidden_labels", &self.forbidden_labels());
            ds.field("est_rows", &self.est_rows());
            ds.field("selectivity", &self.selectivity());
            ds.field("graph_ref", &self.graph_ref());
            ds.finish()
        }
    }
    pub enum ScanRelsOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ScanRelsOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ScanRelsOp<'a> {
        type Inner = ScanRelsOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ScanRelsOp<'a> {
        pub const VT_TYPES: ::flatbuffers::VOffsetT = 4;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 6;
        pub const VT_SRC_LABELS: ::flatbuffers::VOffsetT = 8;
        pub const VT_DST_LABELS: ::flatbuffers::VOffsetT = 10;
        pub const VT_EST_ROWS: ::flatbuffers::VOffsetT = 12;
        pub const VT_SELECTIVITY: ::flatbuffers::VOffsetT = 14;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ScanRelsOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ScanRelsOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ScanRelsOp<'bldr>> {
            let mut builder = ScanRelsOpBuilder::new(_fbb);
            builder.add_selectivity(args.selectivity);
            builder.add_est_rows(args.est_rows);
            if let Some(x) = args.dst_labels {
                builder.add_dst_labels(x);
            }
            if let Some(x) = args.src_labels {
                builder.add_src_labels(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.types {
                builder.add_types(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn types(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ScanRelsOp::VT_TYPES, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(ScanRelsOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn src_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ScanRelsOp::VT_SRC_LABELS, None)
            }
        }
        #[inline]
        pub fn dst_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ScanRelsOp::VT_DST_LABELS, None)
            }
        }
        #[inline]
        pub fn est_rows(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i64>(ScanRelsOp::VT_EST_ROWS, Some(-1))
                    .unwrap()
            }
        }
        #[inline]
        pub fn selectivity(&self) -> f64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<f64>(ScanRelsOp::VT_SELECTIVITY, Some(1.0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for ScanRelsOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("types", Self::VT_TYPES, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("src_labels", Self::VT_SRC_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("dst_labels", Self::VT_DST_LABELS, false)?
                .visit_field::<i64>("est_rows", Self::VT_EST_ROWS, false)?
                .visit_field::<f64>("selectivity", Self::VT_SELECTIVITY, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ScanRelsOpArgs<'a> {
        pub types: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub src_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub dst_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub est_rows: i64,
        pub selectivity: f64,
    }
    impl<'a> Default for ScanRelsOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            ScanRelsOpArgs {
                types: None,
                schema: None,
                src_labels: None,
                dst_labels: None,
                est_rows: -1,
                selectivity: 1.0,
            }
        }
    }

    pub struct ScanRelsOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ScanRelsOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_types(
            &mut self,
            types: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ScanRelsOp::VT_TYPES, types);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ScanRelsOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_src_labels(
            &mut self,
            src_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ScanRelsOp::VT_SRC_LABELS,
                src_labels,
            );
        }
        #[inline]
        pub fn add_dst_labels(
            &mut self,
            dst_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ScanRelsOp::VT_DST_LABELS,
                dst_labels,
            );
        }
        #[inline]
        pub fn add_est_rows(&mut self, est_rows: i64) {
            self.fbb_
                .push_slot::<i64>(ScanRelsOp::VT_EST_ROWS, est_rows, -1);
        }
        #[inline]
        pub fn add_selectivity(&mut self, selectivity: f64) {
            self.fbb_
                .push_slot::<f64>(ScanRelsOp::VT_SELECTIVITY, selectivity, 1.0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ScanRelsOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ScanRelsOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ScanRelsOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ScanRelsOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ScanRelsOp");
            ds.field("types", &self.types());
            ds.field("schema", &self.schema());
            ds.field("src_labels", &self.src_labels());
            ds.field("dst_labels", &self.dst_labels());
            ds.field("est_rows", &self.est_rows());
            ds.field("selectivity", &self.selectivity());
            ds.finish()
        }
    }
    pub enum ExpandOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ExpandOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ExpandOp<'a> {
        type Inner = ExpandOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ExpandOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_SRC_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_TYPES: ::flatbuffers::VOffsetT = 8;
        pub const VT_DIR: ::flatbuffers::VOffsetT = 10;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 12;
        pub const VT_SRC_VAR: ::flatbuffers::VOffsetT = 14;
        pub const VT_REL_VAR: ::flatbuffers::VOffsetT = 16;
        pub const VT_DST_VAR: ::flatbuffers::VOffsetT = 18;
        pub const VT_LEGAL_SRC_LABELS: ::flatbuffers::VOffsetT = 20;
        pub const VT_LEGAL_DST_LABELS: ::flatbuffers::VOffsetT = 22;
        pub const VT_EST_DEGREE: ::flatbuffers::VOffsetT = 24;
        pub const VT_GRAPH_REF: ::flatbuffers::VOffsetT = 26;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ExpandOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ExpandOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ExpandOp<'bldr>> {
            let mut builder = ExpandOpBuilder::new(_fbb);
            builder.add_est_degree(args.est_degree);
            if let Some(x) = args.graph_ref {
                builder.add_graph_ref(x);
            }
            if let Some(x) = args.legal_dst_labels {
                builder.add_legal_dst_labels(x);
            }
            if let Some(x) = args.legal_src_labels {
                builder.add_legal_src_labels(x);
            }
            if let Some(x) = args.dst_var {
                builder.add_dst_var(x);
            }
            if let Some(x) = args.rel_var {
                builder.add_rel_var(x);
            }
            if let Some(x) = args.src_var {
                builder.add_src_var(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.types {
                builder.add_types(x);
            }
            builder.add_src_col(args.src_col);
            builder.add_input(args.input);
            builder.add_dir(args.dir);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(ExpandOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn src_col(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(ExpandOp::VT_SRC_COL, Some(0)).unwrap() }
        }
        #[inline]
        pub fn types(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ExpandOp::VT_TYPES, None)
            }
        }
        #[inline]
        pub fn dir(&self) -> ExpandDir {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ExpandDir>(ExpandOp::VT_DIR, Some(ExpandDir::out))
                    .unwrap()
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(ExpandOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn src_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandOp::VT_SRC_VAR, None)
            }
        }
        #[inline]
        pub fn rel_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandOp::VT_REL_VAR, None)
            }
        }
        #[inline]
        pub fn dst_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandOp::VT_DST_VAR, None)
            }
        }
        #[inline]
        pub fn legal_src_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ExpandOp::VT_LEGAL_SRC_LABELS, None)
            }
        }
        #[inline]
        pub fn legal_dst_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ExpandOp::VT_LEGAL_DST_LABELS, None)
            }
        }
        #[inline]
        pub fn est_degree(&self) -> f64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<f64>(ExpandOp::VT_EST_DEGREE, Some(-1.0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn graph_ref(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandOp::VT_GRAPH_REF, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ExpandOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<u32>("src_col", Self::VT_SRC_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("types", Self::VT_TYPES, false)?
                .visit_field::<ExpandDir>("dir", Self::VT_DIR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "src_var",
                    Self::VT_SRC_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "rel_var",
                    Self::VT_REL_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "dst_var",
                    Self::VT_DST_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("legal_src_labels", Self::VT_LEGAL_SRC_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("legal_dst_labels", Self::VT_LEGAL_DST_LABELS, false)?
                .visit_field::<f64>("est_degree", Self::VT_EST_DEGREE, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "graph_ref",
                    Self::VT_GRAPH_REF,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ExpandOpArgs<'a> {
        pub input: u32,
        pub src_col: u32,
        pub types: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub dir: ExpandDir,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub src_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub rel_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub dst_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub legal_src_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub legal_dst_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub est_degree: f64,
        pub graph_ref: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ExpandOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            ExpandOpArgs {
                input: 0,
                src_col: 0,
                types: None,
                dir: ExpandDir::out,
                schema: None,
                src_var: None,
                rel_var: None,
                dst_var: None,
                legal_src_labels: None,
                legal_dst_labels: None,
                est_degree: -1.0,
                graph_ref: None,
            }
        }
    }

    pub struct ExpandOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ExpandOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(ExpandOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_src_col(&mut self, src_col: u32) {
            self.fbb_.push_slot::<u32>(ExpandOp::VT_SRC_COL, src_col, 0);
        }
        #[inline]
        pub fn add_types(
            &mut self,
            types: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandOp::VT_TYPES, types);
        }
        #[inline]
        pub fn add_dir(&mut self, dir: ExpandDir) {
            self.fbb_
                .push_slot::<ExpandDir>(ExpandOp::VT_DIR, dir, ExpandDir::out);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_src_var(&mut self, src_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandOp::VT_SRC_VAR, src_var);
        }
        #[inline]
        pub fn add_rel_var(&mut self, rel_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandOp::VT_REL_VAR, rel_var);
        }
        #[inline]
        pub fn add_dst_var(&mut self, dst_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandOp::VT_DST_VAR, dst_var);
        }
        #[inline]
        pub fn add_legal_src_labels(
            &mut self,
            legal_src_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ExpandOp::VT_LEGAL_SRC_LABELS,
                legal_src_labels,
            );
        }
        #[inline]
        pub fn add_legal_dst_labels(
            &mut self,
            legal_dst_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ExpandOp::VT_LEGAL_DST_LABELS,
                legal_dst_labels,
            );
        }
        #[inline]
        pub fn add_est_degree(&mut self, est_degree: f64) {
            self.fbb_
                .push_slot::<f64>(ExpandOp::VT_EST_DEGREE, est_degree, -1.0);
        }
        #[inline]
        pub fn add_graph_ref(&mut self, graph_ref: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandOp::VT_GRAPH_REF, graph_ref);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ExpandOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ExpandOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ExpandOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ExpandOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ExpandOp");
            ds.field("input", &self.input());
            ds.field("src_col", &self.src_col());
            ds.field("types", &self.types());
            ds.field("dir", &self.dir());
            ds.field("schema", &self.schema());
            ds.field("src_var", &self.src_var());
            ds.field("rel_var", &self.rel_var());
            ds.field("dst_var", &self.dst_var());
            ds.field("legal_src_labels", &self.legal_src_labels());
            ds.field("legal_dst_labels", &self.legal_dst_labels());
            ds.field("est_degree", &self.est_degree());
            ds.field("graph_ref", &self.graph_ref());
            ds.finish()
        }
    }
    pub enum OptionalExpandOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct OptionalExpandOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for OptionalExpandOp<'a> {
        type Inner = OptionalExpandOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> OptionalExpandOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_SRC_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_TYPES: ::flatbuffers::VOffsetT = 8;
        pub const VT_DIR: ::flatbuffers::VOffsetT = 10;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 12;
        pub const VT_SRC_VAR: ::flatbuffers::VOffsetT = 14;
        pub const VT_REL_VAR: ::flatbuffers::VOffsetT = 16;
        pub const VT_DST_VAR: ::flatbuffers::VOffsetT = 18;
        pub const VT_LEGAL_SRC_LABELS: ::flatbuffers::VOffsetT = 20;
        pub const VT_LEGAL_DST_LABELS: ::flatbuffers::VOffsetT = 22;
        pub const VT_GRAPH_REF: ::flatbuffers::VOffsetT = 24;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            OptionalExpandOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args OptionalExpandOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<OptionalExpandOp<'bldr>> {
            let mut builder = OptionalExpandOpBuilder::new(_fbb);
            if let Some(x) = args.graph_ref {
                builder.add_graph_ref(x);
            }
            if let Some(x) = args.legal_dst_labels {
                builder.add_legal_dst_labels(x);
            }
            if let Some(x) = args.legal_src_labels {
                builder.add_legal_src_labels(x);
            }
            if let Some(x) = args.dst_var {
                builder.add_dst_var(x);
            }
            if let Some(x) = args.rel_var {
                builder.add_rel_var(x);
            }
            if let Some(x) = args.src_var {
                builder.add_src_var(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.types {
                builder.add_types(x);
            }
            builder.add_src_col(args.src_col);
            builder.add_input(args.input);
            builder.add_dir(args.dir);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(OptionalExpandOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn src_col(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(OptionalExpandOp::VT_SRC_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn types(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(OptionalExpandOp::VT_TYPES, None)
            }
        }
        #[inline]
        pub fn dir(&self) -> ExpandDir {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ExpandDir>(OptionalExpandOp::VT_DIR, Some(ExpandDir::out))
                    .unwrap()
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(OptionalExpandOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn src_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(OptionalExpandOp::VT_SRC_VAR, None)
            }
        }
        #[inline]
        pub fn rel_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(OptionalExpandOp::VT_REL_VAR, None)
            }
        }
        #[inline]
        pub fn dst_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(OptionalExpandOp::VT_DST_VAR, None)
            }
        }
        #[inline]
        pub fn legal_src_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(OptionalExpandOp::VT_LEGAL_SRC_LABELS, None)
            }
        }
        #[inline]
        pub fn legal_dst_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(OptionalExpandOp::VT_LEGAL_DST_LABELS, None)
            }
        }
        #[inline]
        pub fn graph_ref(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                    OptionalExpandOp::VT_GRAPH_REF,
                    None,
                )
            }
        }
    }

    impl ::flatbuffers::Verifiable for OptionalExpandOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<u32>("src_col", Self::VT_SRC_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("types", Self::VT_TYPES, false)?
                .visit_field::<ExpandDir>("dir", Self::VT_DIR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "src_var",
                    Self::VT_SRC_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "rel_var",
                    Self::VT_REL_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "dst_var",
                    Self::VT_DST_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("legal_src_labels", Self::VT_LEGAL_SRC_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("legal_dst_labels", Self::VT_LEGAL_DST_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "graph_ref",
                    Self::VT_GRAPH_REF,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct OptionalExpandOpArgs<'a> {
        pub input: u32,
        pub src_col: u32,
        pub types: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub dir: ExpandDir,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub src_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub rel_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub dst_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub legal_src_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub legal_dst_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub graph_ref: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for OptionalExpandOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            OptionalExpandOpArgs {
                input: 0,
                src_col: 0,
                types: None,
                dir: ExpandDir::out,
                schema: None,
                src_var: None,
                rel_var: None,
                dst_var: None,
                legal_src_labels: None,
                legal_dst_labels: None,
                graph_ref: None,
            }
        }
    }

    pub struct OptionalExpandOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OptionalExpandOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_
                .push_slot::<u32>(OptionalExpandOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_src_col(&mut self, src_col: u32) {
            self.fbb_
                .push_slot::<u32>(OptionalExpandOp::VT_SRC_COL, src_col, 0);
        }
        #[inline]
        pub fn add_types(
            &mut self,
            types: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(OptionalExpandOp::VT_TYPES, types);
        }
        #[inline]
        pub fn add_dir(&mut self, dir: ExpandDir) {
            self.fbb_
                .push_slot::<ExpandDir>(OptionalExpandOp::VT_DIR, dir, ExpandDir::out);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_SCHEMA,
                schema,
            );
        }
        #[inline]
        pub fn add_src_var(&mut self, src_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_SRC_VAR,
                src_var,
            );
        }
        #[inline]
        pub fn add_rel_var(&mut self, rel_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_REL_VAR,
                rel_var,
            );
        }
        #[inline]
        pub fn add_dst_var(&mut self, dst_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_DST_VAR,
                dst_var,
            );
        }
        #[inline]
        pub fn add_legal_src_labels(
            &mut self,
            legal_src_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_LEGAL_SRC_LABELS,
                legal_src_labels,
            );
        }
        #[inline]
        pub fn add_legal_dst_labels(
            &mut self,
            legal_dst_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_LEGAL_DST_LABELS,
                legal_dst_labels,
            );
        }
        #[inline]
        pub fn add_graph_ref(&mut self, graph_ref: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                OptionalExpandOp::VT_GRAPH_REF,
                graph_ref,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> OptionalExpandOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            OptionalExpandOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<OptionalExpandOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for OptionalExpandOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("OptionalExpandOp");
            ds.field("input", &self.input());
            ds.field("src_col", &self.src_col());
            ds.field("types", &self.types());
            ds.field("dir", &self.dir());
            ds.field("schema", &self.schema());
            ds.field("src_var", &self.src_var());
            ds.field("rel_var", &self.rel_var());
            ds.field("dst_var", &self.dst_var());
            ds.field("legal_src_labels", &self.legal_src_labels());
            ds.field("legal_dst_labels", &self.legal_dst_labels());
            ds.field("graph_ref", &self.graph_ref());
            ds.finish()
        }
    }
    pub enum SemiExpandOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct SemiExpandOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for SemiExpandOp<'a> {
        type Inner = SemiExpandOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> SemiExpandOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_SRC_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_TYPES: ::flatbuffers::VOffsetT = 8;
        pub const VT_DIR: ::flatbuffers::VOffsetT = 10;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 12;
        pub const VT_LEGAL_SRC_LABELS: ::flatbuffers::VOffsetT = 14;
        pub const VT_LEGAL_DST_LABELS: ::flatbuffers::VOffsetT = 16;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            SemiExpandOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args SemiExpandOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<SemiExpandOp<'bldr>> {
            let mut builder = SemiExpandOpBuilder::new(_fbb);
            if let Some(x) = args.legal_dst_labels {
                builder.add_legal_dst_labels(x);
            }
            if let Some(x) = args.legal_src_labels {
                builder.add_legal_src_labels(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.types {
                builder.add_types(x);
            }
            builder.add_src_col(args.src_col);
            builder.add_input(args.input);
            builder.add_dir(args.dir);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(SemiExpandOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn src_col(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(SemiExpandOp::VT_SRC_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn types(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(SemiExpandOp::VT_TYPES, None)
            }
        }
        #[inline]
        pub fn dir(&self) -> ExpandDir {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ExpandDir>(SemiExpandOp::VT_DIR, Some(ExpandDir::out))
                    .unwrap()
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(SemiExpandOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn legal_src_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(SemiExpandOp::VT_LEGAL_SRC_LABELS, None)
            }
        }
        #[inline]
        pub fn legal_dst_labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(SemiExpandOp::VT_LEGAL_DST_LABELS, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for SemiExpandOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<u32>("src_col", Self::VT_SRC_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("types", Self::VT_TYPES, false)?
                .visit_field::<ExpandDir>("dir", Self::VT_DIR, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("legal_src_labels", Self::VT_LEGAL_SRC_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("legal_dst_labels", Self::VT_LEGAL_DST_LABELS, false)?
                .finish();
            Ok(())
        }
    }
    pub struct SemiExpandOpArgs<'a> {
        pub input: u32,
        pub src_col: u32,
        pub types: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub dir: ExpandDir,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub legal_src_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub legal_dst_labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
    }
    impl<'a> Default for SemiExpandOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            SemiExpandOpArgs {
                input: 0,
                src_col: 0,
                types: None,
                dir: ExpandDir::out,
                schema: None,
                legal_src_labels: None,
                legal_dst_labels: None,
            }
        }
    }

    pub struct SemiExpandOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SemiExpandOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(SemiExpandOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_src_col(&mut self, src_col: u32) {
            self.fbb_
                .push_slot::<u32>(SemiExpandOp::VT_SRC_COL, src_col, 0);
        }
        #[inline]
        pub fn add_types(
            &mut self,
            types: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SemiExpandOp::VT_TYPES, types);
        }
        #[inline]
        pub fn add_dir(&mut self, dir: ExpandDir) {
            self.fbb_
                .push_slot::<ExpandDir>(SemiExpandOp::VT_DIR, dir, ExpandDir::out);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SemiExpandOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_legal_src_labels(
            &mut self,
            legal_src_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                SemiExpandOp::VT_LEGAL_SRC_LABELS,
                legal_src_labels,
            );
        }
        #[inline]
        pub fn add_legal_dst_labels(
            &mut self,
            legal_dst_labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                SemiExpandOp::VT_LEGAL_DST_LABELS,
                legal_dst_labels,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> SemiExpandOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            SemiExpandOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<SemiExpandOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for SemiExpandOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("SemiExpandOp");
            ds.field("input", &self.input());
            ds.field("src_col", &self.src_col());
            ds.field("types", &self.types());
            ds.field("dir", &self.dir());
            ds.field("schema", &self.schema());
            ds.field("legal_src_labels", &self.legal_src_labels());
            ds.field("legal_dst_labels", &self.legal_dst_labels());
            ds.finish()
        }
    }
    pub enum ExpandVarLenOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ExpandVarLenOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ExpandVarLenOp<'a> {
        type Inner = ExpandVarLenOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ExpandVarLenOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_SRC_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_TYPES: ::flatbuffers::VOffsetT = 8;
        pub const VT_DIR: ::flatbuffers::VOffsetT = 10;
        pub const VT_MIN_HOPS: ::flatbuffers::VOffsetT = 12;
        pub const VT_MAX_HOPS: ::flatbuffers::VOffsetT = 14;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 16;
        pub const VT_SRC_VAR: ::flatbuffers::VOffsetT = 18;
        pub const VT_PATH_VAR: ::flatbuffers::VOffsetT = 20;
        pub const VT_DST_VAR: ::flatbuffers::VOffsetT = 22;
        pub const VT_GRAPH_REF: ::flatbuffers::VOffsetT = 24;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ExpandVarLenOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ExpandVarLenOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ExpandVarLenOp<'bldr>> {
            let mut builder = ExpandVarLenOpBuilder::new(_fbb);
            if let Some(x) = args.graph_ref {
                builder.add_graph_ref(x);
            }
            if let Some(x) = args.dst_var {
                builder.add_dst_var(x);
            }
            if let Some(x) = args.path_var {
                builder.add_path_var(x);
            }
            if let Some(x) = args.src_var {
                builder.add_src_var(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            builder.add_max_hops(args.max_hops);
            builder.add_min_hops(args.min_hops);
            if let Some(x) = args.types {
                builder.add_types(x);
            }
            builder.add_src_col(args.src_col);
            builder.add_input(args.input);
            builder.add_dir(args.dir);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(ExpandVarLenOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn src_col(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(ExpandVarLenOp::VT_SRC_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn types(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(ExpandVarLenOp::VT_TYPES, None)
            }
        }
        #[inline]
        pub fn dir(&self) -> ExpandDir {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<ExpandDir>(ExpandVarLenOp::VT_DIR, Some(ExpandDir::out))
                    .unwrap()
            }
        }
        #[inline]
        pub fn min_hops(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(ExpandVarLenOp::VT_MIN_HOPS, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn max_hops(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(ExpandVarLenOp::VT_MAX_HOPS, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(ExpandVarLenOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn src_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandVarLenOp::VT_SRC_VAR, None)
            }
        }
        #[inline]
        pub fn path_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandVarLenOp::VT_PATH_VAR, None)
            }
        }
        #[inline]
        pub fn dst_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandVarLenOp::VT_DST_VAR, None)
            }
        }
        #[inline]
        pub fn graph_ref(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(ExpandVarLenOp::VT_GRAPH_REF, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ExpandVarLenOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<u32>("src_col", Self::VT_SRC_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("types", Self::VT_TYPES, false)?
                .visit_field::<ExpandDir>("dir", Self::VT_DIR, false)?
                .visit_field::<i32>("min_hops", Self::VT_MIN_HOPS, false)?
                .visit_field::<i32>("max_hops", Self::VT_MAX_HOPS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "src_var",
                    Self::VT_SRC_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "path_var",
                    Self::VT_PATH_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "dst_var",
                    Self::VT_DST_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "graph_ref",
                    Self::VT_GRAPH_REF,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ExpandVarLenOpArgs<'a> {
        pub input: u32,
        pub src_col: u32,
        pub types: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub dir: ExpandDir,
        pub min_hops: i32,
        pub max_hops: i32,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub src_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub path_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub dst_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub graph_ref: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ExpandVarLenOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            ExpandVarLenOpArgs {
                input: 0,
                src_col: 0,
                types: None,
                dir: ExpandDir::out,
                min_hops: 0,
                max_hops: 0,
                schema: None,
                src_var: None,
                path_var: None,
                dst_var: None,
                graph_ref: None,
            }
        }
    }

    pub struct ExpandVarLenOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ExpandVarLenOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_
                .push_slot::<u32>(ExpandVarLenOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_src_col(&mut self, src_col: u32) {
            self.fbb_
                .push_slot::<u32>(ExpandVarLenOp::VT_SRC_COL, src_col, 0);
        }
        #[inline]
        pub fn add_types(
            &mut self,
            types: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandVarLenOp::VT_TYPES, types);
        }
        #[inline]
        pub fn add_dir(&mut self, dir: ExpandDir) {
            self.fbb_
                .push_slot::<ExpandDir>(ExpandVarLenOp::VT_DIR, dir, ExpandDir::out);
        }
        #[inline]
        pub fn add_min_hops(&mut self, min_hops: i32) {
            self.fbb_
                .push_slot::<i32>(ExpandVarLenOp::VT_MIN_HOPS, min_hops, 0);
        }
        #[inline]
        pub fn add_max_hops(&mut self, max_hops: i32) {
            self.fbb_
                .push_slot::<i32>(ExpandVarLenOp::VT_MAX_HOPS, max_hops, 0);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ExpandVarLenOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_src_var(&mut self, src_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ExpandVarLenOp::VT_SRC_VAR,
                src_var,
            );
        }
        #[inline]
        pub fn add_path_var(&mut self, path_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ExpandVarLenOp::VT_PATH_VAR,
                path_var,
            );
        }
        #[inline]
        pub fn add_dst_var(&mut self, dst_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ExpandVarLenOp::VT_DST_VAR,
                dst_var,
            );
        }
        #[inline]
        pub fn add_graph_ref(&mut self, graph_ref: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                ExpandVarLenOp::VT_GRAPH_REF,
                graph_ref,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ExpandVarLenOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ExpandVarLenOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ExpandVarLenOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ExpandVarLenOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ExpandVarLenOp");
            ds.field("input", &self.input());
            ds.field("src_col", &self.src_col());
            ds.field("types", &self.types());
            ds.field("dir", &self.dir());
            ds.field("min_hops", &self.min_hops());
            ds.field("max_hops", &self.max_hops());
            ds.field("schema", &self.schema());
            ds.field("src_var", &self.src_var());
            ds.field("path_var", &self.path_var());
            ds.field("dst_var", &self.dst_var());
            ds.field("graph_ref", &self.graph_ref());
            ds.finish()
        }
    }
    pub enum FilterOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct FilterOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for FilterOp<'a> {
        type Inner = FilterOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> FilterOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_PREDICATE: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            FilterOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args FilterOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<FilterOp<'bldr>> {
            let mut builder = FilterOpBuilder::new(_fbb);
            if let Some(x) = args.predicate {
                builder.add_predicate(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(FilterOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn predicate(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(FilterOp::VT_PREDICATE, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for FilterOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "predicate",
                    Self::VT_PREDICATE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct FilterOpArgs<'a> {
        pub input: u32,
        pub predicate: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
    }
    impl<'a> Default for FilterOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            FilterOpArgs {
                input: 0,
                predicate: None,
            }
        }
    }

    pub struct FilterOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> FilterOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(FilterOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_predicate(&mut self, predicate: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    FilterOp::VT_PREDICATE,
                    predicate,
                );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> FilterOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            FilterOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<FilterOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for FilterOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("FilterOp");
            ds.field("input", &self.input());
            ds.field("predicate", &self.predicate());
            ds.finish()
        }
    }
    pub enum BlockMarkerOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct BlockMarkerOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for BlockMarkerOp<'a> {
        type Inner = BlockMarkerOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> BlockMarkerOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_BLOCK_ID: ::flatbuffers::VOffsetT = 6;
        pub const VT_BRANCH_ID: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            BlockMarkerOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args BlockMarkerOpArgs,
        ) -> ::flatbuffers::WIPOffset<BlockMarkerOp<'bldr>> {
            let mut builder = BlockMarkerOpBuilder::new(_fbb);
            builder.add_branch_id(args.branch_id);
            builder.add_block_id(args.block_id);
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(BlockMarkerOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn block_id(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(BlockMarkerOp::VT_BLOCK_ID, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn branch_id(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(BlockMarkerOp::VT_BRANCH_ID, Some(0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for BlockMarkerOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<i32>("block_id", Self::VT_BLOCK_ID, false)?
                .visit_field::<i32>("branch_id", Self::VT_BRANCH_ID, false)?
                .finish();
            Ok(())
        }
    }
    pub struct BlockMarkerOpArgs {
        pub input: u32,
        pub block_id: i32,
        pub branch_id: i32,
    }
    impl<'a> Default for BlockMarkerOpArgs {
        #[inline]
        fn default() -> Self {
            BlockMarkerOpArgs {
                input: 0,
                block_id: 0,
                branch_id: 0,
            }
        }
    }

    pub struct BlockMarkerOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> BlockMarkerOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_
                .push_slot::<u32>(BlockMarkerOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_block_id(&mut self, block_id: i32) {
            self.fbb_
                .push_slot::<i32>(BlockMarkerOp::VT_BLOCK_ID, block_id, 0);
        }
        #[inline]
        pub fn add_branch_id(&mut self, branch_id: i32) {
            self.fbb_
                .push_slot::<i32>(BlockMarkerOp::VT_BRANCH_ID, branch_id, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> BlockMarkerOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            BlockMarkerOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<BlockMarkerOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for BlockMarkerOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("BlockMarkerOp");
            ds.field("input", &self.input());
            ds.field("block_id", &self.block_id());
            ds.field("branch_id", &self.branch_id());
            ds.finish()
        }
    }
    pub enum ProjectOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ProjectOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ProjectOp<'a> {
        type Inner = ProjectOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ProjectOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_EXPRS: ::flatbuffers::VOffsetT = 6;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ProjectOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ProjectOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<ProjectOp<'bldr>> {
            let mut builder = ProjectOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.exprs {
                builder.add_exprs(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(ProjectOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn exprs(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>(ProjectOp::VT_EXPRS, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(ProjectOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for ProjectOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>("exprs", Self::VT_EXPRS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ProjectOpArgs<'a> {
        pub input: u32,
        pub exprs: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>,
            >,
        >,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for ProjectOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            ProjectOpArgs {
                input: 0,
                exprs: None,
                schema: None,
            }
        }
    }

    pub struct ProjectOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ProjectOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(ProjectOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_exprs(
            &mut self,
            exprs: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Expr<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ProjectOp::VT_EXPRS, exprs);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ProjectOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ProjectOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ProjectOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ProjectOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ProjectOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ProjectOp");
            ds.field("input", &self.input());
            ds.field("exprs", &self.exprs());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum AggregateOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct AggregateOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for AggregateOp<'a> {
        type Inner = AggregateOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> AggregateOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_KEYS: ::flatbuffers::VOffsetT = 6;
        pub const VT_AGGS: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            AggregateOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args AggregateOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<AggregateOp<'bldr>> {
            let mut builder = AggregateOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.aggs {
                builder.add_aggs(x);
            }
            if let Some(x) = args.keys {
                builder.add_keys(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(AggregateOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn keys(&self) -> Option<::flatbuffers::Vector<'a, u32>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u32>>>(
                        AggregateOp::VT_KEYS,
                        None,
                    )
            }
        }
        #[inline]
        pub fn aggs(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>(AggregateOp::VT_AGGS, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(AggregateOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for AggregateOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u32>>>(
                    "keys",
                    Self::VT_KEYS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Expr>>,
                >>("aggs", Self::VT_AGGS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct AggregateOpArgs<'a> {
        pub input: u32,
        pub keys: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u32>>>,
        pub aggs: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Expr<'a>>>,
            >,
        >,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for AggregateOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            AggregateOpArgs {
                input: 0,
                keys: None,
                aggs: None,
                schema: None,
            }
        }
    }

    pub struct AggregateOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AggregateOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(AggregateOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_keys(&mut self, keys: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u32>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(AggregateOp::VT_KEYS, keys);
        }
        #[inline]
        pub fn add_aggs(
            &mut self,
            aggs: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<Expr<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(AggregateOp::VT_AGGS, aggs);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(AggregateOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> AggregateOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            AggregateOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<AggregateOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for AggregateOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("AggregateOp");
            ds.field("input", &self.input());
            ds.field("keys", &self.keys());
            ds.field("aggs", &self.aggs());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum SortOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct SortOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for SortOp<'a> {
        type Inner = SortOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> SortOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_KEYS: ::flatbuffers::VOffsetT = 6;
        pub const VT_DIRS: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            SortOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args SortOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<SortOp<'bldr>> {
            let mut builder = SortOpBuilder::new(_fbb);
            if let Some(x) = args.dirs {
                builder.add_dirs(x);
            }
            if let Some(x) = args.keys {
                builder.add_keys(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(SortOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn keys(&self) -> Option<::flatbuffers::Vector<'a, u32>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u32>>>(
                        SortOp::VT_KEYS,
                        None,
                    )
            }
        }
        #[inline]
        pub fn dirs(&self) -> Option<::flatbuffers::Vector<'a, SortDir>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, SortDir>>>(
                        SortOp::VT_DIRS,
                        None,
                    )
            }
        }
    }

    impl ::flatbuffers::Verifiable for SortOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u32>>>(
                    "keys",
                    Self::VT_KEYS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, SortDir>>>(
                    "dirs",
                    Self::VT_DIRS,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct SortOpArgs<'a> {
        pub input: u32,
        pub keys: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u32>>>,
        pub dirs: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, SortDir>>>,
    }
    impl<'a> Default for SortOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            SortOpArgs {
                input: 0,
                keys: None,
                dirs: None,
            }
        }
    }

    pub struct SortOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SortOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(SortOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_keys(&mut self, keys: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u32>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SortOp::VT_KEYS, keys);
        }
        #[inline]
        pub fn add_dirs(
            &mut self,
            dirs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, SortDir>>,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SortOp::VT_DIRS, dirs);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> SortOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            SortOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<SortOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for SortOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("SortOp");
            ds.field("input", &self.input());
            ds.field("keys", &self.keys());
            ds.field("dirs", &self.dirs());
            ds.finish()
        }
    }
    pub enum LimitOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct LimitOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for LimitOp<'a> {
        type Inner = LimitOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> LimitOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_COUNT: ::flatbuffers::VOffsetT = 6;
        pub const VT_SKIP: ::flatbuffers::VOffsetT = 8;
        pub const VT_CURSOR: ::flatbuffers::VOffsetT = 10;
        pub const VT_EMIT_CURSOR: ::flatbuffers::VOffsetT = 12;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            LimitOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args LimitOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<LimitOp<'bldr>> {
            let mut builder = LimitOpBuilder::new(_fbb);
            builder.add_skip(args.skip);
            builder.add_count(args.count);
            if let Some(x) = args.cursor {
                builder.add_cursor(x);
            }
            builder.add_input(args.input);
            builder.add_emit_cursor(args.emit_cursor);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(LimitOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn count(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i64>(LimitOp::VT_COUNT, Some(-1)).unwrap() }
        }
        #[inline]
        pub fn skip(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i64>(LimitOp::VT_SKIP, Some(0)).unwrap() }
        }
        #[inline]
        pub fn cursor(&self) -> Option<::flatbuffers::Vector<'a, i8>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, i8>,
                >>(LimitOp::VT_CURSOR, None)
            }
        }
        #[inline]
        pub fn emit_cursor(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(LimitOp::VT_EMIT_CURSOR, Some(false))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for LimitOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<i64>("count", Self::VT_COUNT, false)?
                .visit_field::<i64>("skip", Self::VT_SKIP, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, i8>,
                >>("cursor", Self::VT_CURSOR, false)?
                .visit_field::<bool>("emit_cursor", Self::VT_EMIT_CURSOR, false)?
                .finish();
            Ok(())
        }
    }
    pub struct LimitOpArgs<'a> {
        pub input: u32,
        pub count: i64,
        pub skip: i64,
        pub cursor: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, i8>>>,
        pub emit_cursor: bool,
    }
    impl<'a> Default for LimitOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            LimitOpArgs {
                input: 0,
                count: -1,
                skip: 0,
                cursor: None,
                emit_cursor: false,
            }
        }
    }

    pub struct LimitOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> LimitOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(LimitOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_count(&mut self, count: i64) {
            self.fbb_.push_slot::<i64>(LimitOp::VT_COUNT, count, -1);
        }
        #[inline]
        pub fn add_skip(&mut self, skip: i64) {
            self.fbb_.push_slot::<i64>(LimitOp::VT_SKIP, skip, 0);
        }
        #[inline]
        pub fn add_cursor(
            &mut self,
            cursor: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, i8>>,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(LimitOp::VT_CURSOR, cursor);
        }
        #[inline]
        pub fn add_emit_cursor(&mut self, emit_cursor: bool) {
            self.fbb_
                .push_slot::<bool>(LimitOp::VT_EMIT_CURSOR, emit_cursor, false);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> LimitOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            LimitOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<LimitOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for LimitOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("LimitOp");
            ds.field("input", &self.input());
            ds.field("count", &self.count());
            ds.field("skip", &self.skip());
            ds.field("cursor", &self.cursor());
            ds.field("emit_cursor", &self.emit_cursor());
            ds.finish()
        }
    }
    pub enum UnwindOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct UnwindOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for UnwindOp<'a> {
        type Inner = UnwindOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> UnwindOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_LIST_EXPR: ::flatbuffers::VOffsetT = 6;
        pub const VT_OUT_VAR: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            UnwindOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args UnwindOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<UnwindOp<'bldr>> {
            let mut builder = UnwindOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.out_var {
                builder.add_out_var(x);
            }
            if let Some(x) = args.list_expr {
                builder.add_list_expr(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(UnwindOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn list_expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(UnwindOp::VT_LIST_EXPR, None)
            }
        }
        #[inline]
        pub fn out_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(UnwindOp::VT_OUT_VAR, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(UnwindOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for UnwindOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "list_expr",
                    Self::VT_LIST_EXPR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "out_var",
                    Self::VT_OUT_VAR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct UnwindOpArgs<'a> {
        pub input: u32,
        pub list_expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub out_var: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for UnwindOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            UnwindOpArgs {
                input: 0,
                list_expr: None,
                out_var: None,
                schema: None,
            }
        }
    }

    pub struct UnwindOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UnwindOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(UnwindOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_list_expr(&mut self, list_expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    UnwindOp::VT_LIST_EXPR,
                    list_expr,
                );
        }
        #[inline]
        pub fn add_out_var(&mut self, out_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(UnwindOp::VT_OUT_VAR, out_var);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(UnwindOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> UnwindOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            UnwindOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<UnwindOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for UnwindOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("UnwindOp");
            ds.field("input", &self.input());
            ds.field("list_expr", &self.list_expr());
            ds.field("out_var", &self.out_var());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum PathConstructOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct PathConstructOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for PathConstructOp<'a> {
        type Inner = PathConstructOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> PathConstructOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_REL_COLS: ::flatbuffers::VOffsetT = 6;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            PathConstructOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args PathConstructOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<PathConstructOp<'bldr>> {
            let mut builder = PathConstructOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.rel_cols {
                builder.add_rel_cols(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(PathConstructOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn rel_cols(&self) -> Option<::flatbuffers::Vector<'a, u32>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u32>>>(
                        PathConstructOp::VT_REL_COLS,
                        None,
                    )
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(PathConstructOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for PathConstructOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u32>>>(
                    "rel_cols",
                    Self::VT_REL_COLS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct PathConstructOpArgs<'a> {
        pub input: u32,
        pub rel_cols: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u32>>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for PathConstructOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            PathConstructOpArgs {
                input: 0,
                rel_cols: None,
                schema: None,
            }
        }
    }

    pub struct PathConstructOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PathConstructOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_
                .push_slot::<u32>(PathConstructOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_rel_cols(
            &mut self,
            rel_cols: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u32>>,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                PathConstructOp::VT_REL_COLS,
                rel_cols,
            );
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                PathConstructOp::VT_SCHEMA,
                schema,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> PathConstructOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            PathConstructOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<PathConstructOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for PathConstructOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("PathConstructOp");
            ds.field("input", &self.input());
            ds.field("rel_cols", &self.rel_cols());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum UnionOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct UnionOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for UnionOp<'a> {
        type Inner = UnionOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> UnionOp<'a> {
        pub const VT_LHS: ::flatbuffers::VOffsetT = 4;
        pub const VT_RHS: ::flatbuffers::VOffsetT = 6;
        pub const VT_ALL: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            UnionOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args UnionOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<UnionOp<'bldr>> {
            let mut builder = UnionOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            builder.add_rhs(args.rhs);
            builder.add_lhs(args.lhs);
            builder.add_all(args.all);
            builder.finish()
        }

        #[inline]
        pub fn lhs(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(UnionOp::VT_LHS, Some(0)).unwrap() }
        }
        #[inline]
        pub fn rhs(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(UnionOp::VT_RHS, Some(0)).unwrap() }
        }
        #[inline]
        pub fn all(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(UnionOp::VT_ALL, Some(false)).unwrap() }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(UnionOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for UnionOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("lhs", Self::VT_LHS, false)?
                .visit_field::<u32>("rhs", Self::VT_RHS, false)?
                .visit_field::<bool>("all", Self::VT_ALL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct UnionOpArgs<'a> {
        pub lhs: u32,
        pub rhs: u32,
        pub all: bool,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for UnionOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            UnionOpArgs {
                lhs: 0,
                rhs: 0,
                all: false,
                schema: None,
            }
        }
    }

    pub struct UnionOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UnionOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_lhs(&mut self, lhs: u32) {
            self.fbb_.push_slot::<u32>(UnionOp::VT_LHS, lhs, 0);
        }
        #[inline]
        pub fn add_rhs(&mut self, rhs: u32) {
            self.fbb_.push_slot::<u32>(UnionOp::VT_RHS, rhs, 0);
        }
        #[inline]
        pub fn add_all(&mut self, all: bool) {
            self.fbb_.push_slot::<bool>(UnionOp::VT_ALL, all, false);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(UnionOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> UnionOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            UnionOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<UnionOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for UnionOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("UnionOp");
            ds.field("lhs", &self.lhs());
            ds.field("rhs", &self.rhs());
            ds.field("all", &self.all());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum CreateNodeOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct CreateNodeOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for CreateNodeOp<'a> {
        type Inner = CreateNodeOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> CreateNodeOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_LABELS: ::flatbuffers::VOffsetT = 6;
        pub const VT_PROPS: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;
        pub const VT_OUT_VAR: ::flatbuffers::VOffsetT = 12;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            CreateNodeOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args CreateNodeOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<CreateNodeOp<'bldr>> {
            let mut builder = CreateNodeOpBuilder::new(_fbb);
            if let Some(x) = args.out_var {
                builder.add_out_var(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.props {
                builder.add_props(x);
            }
            if let Some(x) = args.labels {
                builder.add_labels(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CreateNodeOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn labels(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >>(CreateNodeOp::VT_LABELS, None)
            }
        }
        #[inline]
        pub fn props(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CreateNodeOp::VT_PROPS, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(CreateNodeOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn out_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(CreateNodeOp::VT_OUT_VAR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for CreateNodeOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("labels", Self::VT_LABELS, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "props",
                    Self::VT_PROPS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "out_var",
                    Self::VT_OUT_VAR,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct CreateNodeOpArgs<'a> {
        pub input: u32,
        pub labels: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
            >,
        >,
        pub props: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub out_var: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for CreateNodeOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            CreateNodeOpArgs {
                input: 0,
                labels: None,
                props: None,
                schema: None,
                out_var: None,
            }
        }
    }

    pub struct CreateNodeOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CreateNodeOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(CreateNodeOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_labels(
            &mut self,
            labels: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(CreateNodeOp::VT_LABELS, labels);
        }
        #[inline]
        pub fn add_props(&mut self, props: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(CreateNodeOp::VT_PROPS, props);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(CreateNodeOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_out_var(&mut self, out_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(CreateNodeOp::VT_OUT_VAR, out_var);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> CreateNodeOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            CreateNodeOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<CreateNodeOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for CreateNodeOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("CreateNodeOp");
            ds.field("input", &self.input());
            ds.field("labels", &self.labels());
            ds.field("props", &self.props());
            ds.field("schema", &self.schema());
            ds.field("out_var", &self.out_var());
            ds.finish()
        }
    }
    pub enum CreateRelOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct CreateRelOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for CreateRelOp<'a> {
        type Inner = CreateRelOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> CreateRelOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_SRC_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_DST_COL: ::flatbuffers::VOffsetT = 8;
        pub const VT_REL_TYPE: ::flatbuffers::VOffsetT = 10;
        pub const VT_PROPS: ::flatbuffers::VOffsetT = 12;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 14;
        pub const VT_OUT_VAR: ::flatbuffers::VOffsetT = 16;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            CreateRelOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args CreateRelOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<CreateRelOp<'bldr>> {
            let mut builder = CreateRelOpBuilder::new(_fbb);
            if let Some(x) = args.out_var {
                builder.add_out_var(x);
            }
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.props {
                builder.add_props(x);
            }
            if let Some(x) = args.rel_type {
                builder.add_rel_type(x);
            }
            builder.add_dst_col(args.dst_col);
            builder.add_src_col(args.src_col);
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(CreateRelOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn src_col(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(CreateRelOp::VT_SRC_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn dst_col(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(CreateRelOp::VT_DST_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn rel_type(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(CreateRelOp::VT_REL_TYPE, None)
            }
        }
        #[inline]
        pub fn props(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(CreateRelOp::VT_PROPS, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(CreateRelOp::VT_SCHEMA, None)
            }
        }
        #[inline]
        pub fn out_var(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(CreateRelOp::VT_OUT_VAR, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for CreateRelOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<i32>("src_col", Self::VT_SRC_COL, false)?
                .visit_field::<i32>("dst_col", Self::VT_DST_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "rel_type",
                    Self::VT_REL_TYPE,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "props",
                    Self::VT_PROPS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "out_var",
                    Self::VT_OUT_VAR,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct CreateRelOpArgs<'a> {
        pub input: u32,
        pub src_col: i32,
        pub dst_col: i32,
        pub rel_type: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub props: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
        pub out_var: Option<::flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for CreateRelOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            CreateRelOpArgs {
                input: 0,
                src_col: 0,
                dst_col: 0,
                rel_type: None,
                props: None,
                schema: None,
                out_var: None,
            }
        }
    }

    pub struct CreateRelOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CreateRelOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(CreateRelOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_src_col(&mut self, src_col: i32) {
            self.fbb_
                .push_slot::<i32>(CreateRelOp::VT_SRC_COL, src_col, 0);
        }
        #[inline]
        pub fn add_dst_col(&mut self, dst_col: i32) {
            self.fbb_
                .push_slot::<i32>(CreateRelOp::VT_DST_COL, dst_col, 0);
        }
        #[inline]
        pub fn add_rel_type(&mut self, rel_type: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                CreateRelOp::VT_REL_TYPE,
                rel_type,
            );
        }
        #[inline]
        pub fn add_props(&mut self, props: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(CreateRelOp::VT_PROPS, props);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(CreateRelOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn add_out_var(&mut self, out_var: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(CreateRelOp::VT_OUT_VAR, out_var);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> CreateRelOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            CreateRelOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<CreateRelOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for CreateRelOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("CreateRelOp");
            ds.field("input", &self.input());
            ds.field("src_col", &self.src_col());
            ds.field("dst_col", &self.dst_col());
            ds.field("rel_type", &self.rel_type());
            ds.field("props", &self.props());
            ds.field("schema", &self.schema());
            ds.field("out_var", &self.out_var());
            ds.finish()
        }
    }
    pub enum MergeOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct MergeOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for MergeOp<'a> {
        type Inner = MergeOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> MergeOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_PATTERN: ::flatbuffers::VOffsetT = 6;
        pub const VT_ON_CREATE_PROPS: ::flatbuffers::VOffsetT = 8;
        pub const VT_ON_MATCH_PROPS: ::flatbuffers::VOffsetT = 10;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 12;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            MergeOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args MergeOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<MergeOp<'bldr>> {
            let mut builder = MergeOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.on_match_props {
                builder.add_on_match_props(x);
            }
            if let Some(x) = args.on_create_props {
                builder.add_on_create_props(x);
            }
            if let Some(x) = args.pattern {
                builder.add_pattern(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(MergeOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn pattern(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(MergeOp::VT_PATTERN, None)
            }
        }
        #[inline]
        pub fn on_create_props(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(MergeOp::VT_ON_CREATE_PROPS, None)
            }
        }
        #[inline]
        pub fn on_match_props(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(MergeOp::VT_ON_MATCH_PROPS, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(MergeOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for MergeOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "pattern",
                    Self::VT_PATTERN,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "on_create_props",
                    Self::VT_ON_CREATE_PROPS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "on_match_props",
                    Self::VT_ON_MATCH_PROPS,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct MergeOpArgs<'a> {
        pub input: u32,
        pub pattern: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub on_create_props: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub on_match_props: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for MergeOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            MergeOpArgs {
                input: 0,
                pattern: None,
                on_create_props: None,
                on_match_props: None,
                schema: None,
            }
        }
    }

    pub struct MergeOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MergeOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(MergeOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_pattern(&mut self, pattern: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(MergeOp::VT_PATTERN, pattern);
        }
        #[inline]
        pub fn add_on_create_props(&mut self, on_create_props: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    MergeOp::VT_ON_CREATE_PROPS,
                    on_create_props,
                );
        }
        #[inline]
        pub fn add_on_match_props(&mut self, on_match_props: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    MergeOp::VT_ON_MATCH_PROPS,
                    on_match_props,
                );
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(MergeOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> MergeOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            MergeOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<MergeOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for MergeOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("MergeOp");
            ds.field("input", &self.input());
            ds.field("pattern", &self.pattern());
            ds.field("on_create_props", &self.on_create_props());
            ds.field("on_match_props", &self.on_match_props());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum DeleteOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct DeleteOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for DeleteOp<'a> {
        type Inner = DeleteOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> DeleteOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_TARGET_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_DETACH: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            DeleteOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args DeleteOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<DeleteOp<'bldr>> {
            let mut builder = DeleteOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            builder.add_target_col(args.target_col);
            builder.add_input(args.input);
            builder.add_detach(args.detach);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(DeleteOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn target_col(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(DeleteOp::VT_TARGET_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn detach(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(DeleteOp::VT_DETACH, Some(false))
                    .unwrap()
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(DeleteOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for DeleteOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<i32>("target_col", Self::VT_TARGET_COL, false)?
                .visit_field::<bool>("detach", Self::VT_DETACH, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct DeleteOpArgs<'a> {
        pub input: u32,
        pub target_col: i32,
        pub detach: bool,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for DeleteOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            DeleteOpArgs {
                input: 0,
                target_col: 0,
                detach: false,
                schema: None,
            }
        }
    }

    pub struct DeleteOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DeleteOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(DeleteOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_target_col(&mut self, target_col: i32) {
            self.fbb_
                .push_slot::<i32>(DeleteOp::VT_TARGET_COL, target_col, 0);
        }
        #[inline]
        pub fn add_detach(&mut self, detach: bool) {
            self.fbb_
                .push_slot::<bool>(DeleteOp::VT_DETACH, detach, false);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(DeleteOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> DeleteOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            DeleteOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<DeleteOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for DeleteOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("DeleteOp");
            ds.field("input", &self.input());
            ds.field("target_col", &self.target_col());
            ds.field("detach", &self.detach());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum SetPropertyOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct SetPropertyOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for SetPropertyOp<'a> {
        type Inner = SetPropertyOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> SetPropertyOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_TARGET_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_KEY: ::flatbuffers::VOffsetT = 8;
        pub const VT_VALUE_EXPR: ::flatbuffers::VOffsetT = 10;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 12;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            SetPropertyOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args SetPropertyOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<SetPropertyOp<'bldr>> {
            let mut builder = SetPropertyOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.value_expr {
                builder.add_value_expr(x);
            }
            if let Some(x) = args.key {
                builder.add_key(x);
            }
            builder.add_target_col(args.target_col);
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(SetPropertyOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn target_col(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(SetPropertyOp::VT_TARGET_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn key(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(SetPropertyOp::VT_KEY, None)
            }
        }
        #[inline]
        pub fn value_expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(SetPropertyOp::VT_VALUE_EXPR, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(SetPropertyOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for SetPropertyOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<i32>("target_col", Self::VT_TARGET_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "value_expr",
                    Self::VT_VALUE_EXPR,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct SetPropertyOpArgs<'a> {
        pub input: u32,
        pub target_col: i32,
        pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub value_expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for SetPropertyOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            SetPropertyOpArgs {
                input: 0,
                target_col: 0,
                key: None,
                value_expr: None,
                schema: None,
            }
        }
    }

    pub struct SetPropertyOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SetPropertyOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_
                .push_slot::<u32>(SetPropertyOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_target_col(&mut self, target_col: i32) {
            self.fbb_
                .push_slot::<i32>(SetPropertyOp::VT_TARGET_COL, target_col, 0);
        }
        #[inline]
        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SetPropertyOp::VT_KEY, key);
        }
        #[inline]
        pub fn add_value_expr(&mut self, value_expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    SetPropertyOp::VT_VALUE_EXPR,
                    value_expr,
                );
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SetPropertyOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> SetPropertyOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            SetPropertyOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<SetPropertyOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for SetPropertyOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("SetPropertyOp");
            ds.field("input", &self.input());
            ds.field("target_col", &self.target_col());
            ds.field("key", &self.key());
            ds.field("value_expr", &self.value_expr());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum RemovePropertyOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct RemovePropertyOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for RemovePropertyOp<'a> {
        type Inner = RemovePropertyOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> RemovePropertyOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_TARGET_COL: ::flatbuffers::VOffsetT = 6;
        pub const VT_KEY: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            RemovePropertyOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args RemovePropertyOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<RemovePropertyOp<'bldr>> {
            let mut builder = RemovePropertyOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            if let Some(x) = args.key {
                builder.add_key(x);
            }
            builder.add_target_col(args.target_col);
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(RemovePropertyOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn target_col(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<i32>(RemovePropertyOp::VT_TARGET_COL, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn key(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(RemovePropertyOp::VT_KEY, None)
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(RemovePropertyOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for RemovePropertyOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<i32>("target_col", Self::VT_TARGET_COL, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct RemovePropertyOpArgs<'a> {
        pub input: u32,
        pub target_col: i32,
        pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for RemovePropertyOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            RemovePropertyOpArgs {
                input: 0,
                target_col: 0,
                key: None,
                schema: None,
            }
        }
    }

    pub struct RemovePropertyOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RemovePropertyOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_
                .push_slot::<u32>(RemovePropertyOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_target_col(&mut self, target_col: i32) {
            self.fbb_
                .push_slot::<i32>(RemovePropertyOp::VT_TARGET_COL, target_col, 0);
        }
        #[inline]
        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(RemovePropertyOp::VT_KEY, key);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                RemovePropertyOp::VT_SCHEMA,
                schema,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> RemovePropertyOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            RemovePropertyOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<RemovePropertyOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for RemovePropertyOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("RemovePropertyOp");
            ds.field("input", &self.input());
            ds.field("target_col", &self.target_col());
            ds.field("key", &self.key());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum VectorScanOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct VectorScanOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for VectorScanOp<'a> {
        type Inner = VectorScanOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> VectorScanOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_COLLECTION: ::flatbuffers::VOffsetT = 6;
        pub const VT_QUERY_VECTOR: ::flatbuffers::VOffsetT = 8;
        pub const VT_METRIC: ::flatbuffers::VOffsetT = 10;
        pub const VT_TOP_K: ::flatbuffers::VOffsetT = 12;
        pub const VT_APPROX_HINT: ::flatbuffers::VOffsetT = 14;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 16;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            VectorScanOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args VectorScanOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<VectorScanOp<'bldr>> {
            let mut builder = VectorScanOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            builder.add_top_k(args.top_k);
            if let Some(x) = args.query_vector {
                builder.add_query_vector(x);
            }
            if let Some(x) = args.collection {
                builder.add_collection(x);
            }
            builder.add_input(args.input);
            builder.add_approx_hint(args.approx_hint);
            builder.add_metric(args.metric);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(VectorScanOp::VT_INPUT, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn collection(&self) -> Option<&'a str> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<&str>>(VectorScanOp::VT_COLLECTION, None)
            }
        }
        #[inline]
        pub fn query_vector(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<Expr>>(
                    VectorScanOp::VT_QUERY_VECTOR,
                    None,
                )
            }
        }
        #[inline]
        pub fn metric(&self) -> VectorMetric {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<VectorMetric>(VectorScanOp::VT_METRIC, Some(VectorMetric::cosine))
                    .unwrap()
            }
        }
        #[inline]
        pub fn top_k(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(VectorScanOp::VT_TOP_K, Some(0))
                    .unwrap()
            }
        }
        #[inline]
        pub fn approx_hint(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<bool>(VectorScanOp::VT_APPROX_HINT, Some(true))
                    .unwrap()
            }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(VectorScanOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for VectorScanOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                    "collection",
                    Self::VT_COLLECTION,
                    false,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "query_vector",
                    Self::VT_QUERY_VECTOR,
                    false,
                )?
                .visit_field::<VectorMetric>("metric", Self::VT_METRIC, false)?
                .visit_field::<u32>("top_k", Self::VT_TOP_K, false)?
                .visit_field::<bool>("approx_hint", Self::VT_APPROX_HINT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct VectorScanOpArgs<'a> {
        pub input: u32,
        pub collection: Option<::flatbuffers::WIPOffset<&'a str>>,
        pub query_vector: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub metric: VectorMetric,
        pub top_k: u32,
        pub approx_hint: bool,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for VectorScanOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            VectorScanOpArgs {
                input: 0,
                collection: None,
                query_vector: None,
                metric: VectorMetric::cosine,
                top_k: 0,
                approx_hint: true,
                schema: None,
            }
        }
    }

    pub struct VectorScanOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> VectorScanOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(VectorScanOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_collection(&mut self, collection: ::flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                VectorScanOp::VT_COLLECTION,
                collection,
            );
        }
        #[inline]
        pub fn add_query_vector(&mut self, query_vector: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    VectorScanOp::VT_QUERY_VECTOR,
                    query_vector,
                );
        }
        #[inline]
        pub fn add_metric(&mut self, metric: VectorMetric) {
            self.fbb_.push_slot::<VectorMetric>(
                VectorScanOp::VT_METRIC,
                metric,
                VectorMetric::cosine,
            );
        }
        #[inline]
        pub fn add_top_k(&mut self, top_k: u32) {
            self.fbb_.push_slot::<u32>(VectorScanOp::VT_TOP_K, top_k, 0);
        }
        #[inline]
        pub fn add_approx_hint(&mut self, approx_hint: bool) {
            self.fbb_
                .push_slot::<bool>(VectorScanOp::VT_APPROX_HINT, approx_hint, true);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(VectorScanOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> VectorScanOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            VectorScanOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<VectorScanOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for VectorScanOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("VectorScanOp");
            ds.field("input", &self.input());
            ds.field("collection", &self.collection());
            ds.field("query_vector", &self.query_vector());
            ds.field("metric", &self.metric());
            ds.field("top_k", &self.top_k());
            ds.field("approx_hint", &self.approx_hint());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum RerankOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct RerankOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for RerankOp<'a> {
        type Inner = RerankOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> RerankOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;
        pub const VT_SCORE_EXPR: ::flatbuffers::VOffsetT = 6;
        pub const VT_TOP_K: ::flatbuffers::VOffsetT = 8;
        pub const VT_SCHEMA: ::flatbuffers::VOffsetT = 10;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            RerankOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args RerankOpArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<RerankOp<'bldr>> {
            let mut builder = RerankOpBuilder::new(_fbb);
            if let Some(x) = args.schema {
                builder.add_schema(x);
            }
            builder.add_top_k(args.top_k);
            if let Some(x) = args.score_expr {
                builder.add_score_expr(x);
            }
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(RerankOp::VT_INPUT, Some(0)).unwrap() }
        }
        #[inline]
        pub fn score_expr(&self) -> Option<Expr<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Expr>>(RerankOp::VT_SCORE_EXPR, None)
            }
        }
        #[inline]
        pub fn top_k(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(RerankOp::VT_TOP_K, Some(0)).unwrap() }
        }
        #[inline]
        pub fn schema(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>(RerankOp::VT_SCHEMA, None)
            }
        }
    }

    impl ::flatbuffers::Verifiable for RerankOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Expr>>(
                    "score_expr",
                    Self::VT_SCORE_EXPR,
                    false,
                )?
                .visit_field::<u32>("top_k", Self::VT_TOP_K, false)?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ColDef>>,
                >>("schema", Self::VT_SCHEMA, false)?
                .finish();
            Ok(())
        }
    }
    pub struct RerankOpArgs<'a> {
        pub input: u32,
        pub score_expr: Option<::flatbuffers::WIPOffset<Expr<'a>>>,
        pub top_k: u32,
        pub schema: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ColDef<'a>>>,
            >,
        >,
    }
    impl<'a> Default for RerankOpArgs<'a> {
        #[inline]
        fn default() -> Self {
            RerankOpArgs {
                input: 0,
                score_expr: None,
                top_k: 0,
                schema: None,
            }
        }
    }

    pub struct RerankOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RerankOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(RerankOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn add_score_expr(&mut self, score_expr: ::flatbuffers::WIPOffset<Expr<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Expr>>(
                    RerankOp::VT_SCORE_EXPR,
                    score_expr,
                );
        }
        #[inline]
        pub fn add_top_k(&mut self, top_k: u32) {
            self.fbb_.push_slot::<u32>(RerankOp::VT_TOP_K, top_k, 0);
        }
        #[inline]
        pub fn add_schema(
            &mut self,
            schema: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ColDef<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(RerankOp::VT_SCHEMA, schema);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> RerankOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            RerankOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<RerankOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for RerankOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("RerankOp");
            ds.field("input", &self.input());
            ds.field("score_expr", &self.score_expr());
            ds.field("top_k", &self.top_k());
            ds.field("schema", &self.schema());
            ds.finish()
        }
    }
    pub enum ReturnOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct ReturnOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ReturnOp<'a> {
        type Inner = ReturnOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ReturnOp<'a> {
        pub const VT_INPUT: ::flatbuffers::VOffsetT = 4;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ReturnOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args ReturnOpArgs,
        ) -> ::flatbuffers::WIPOffset<ReturnOp<'bldr>> {
            let mut builder = ReturnOpBuilder::new(_fbb);
            builder.add_input(args.input);
            builder.finish()
        }

        #[inline]
        pub fn input(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(ReturnOp::VT_INPUT, Some(0)).unwrap() }
        }
    }

    impl ::flatbuffers::Verifiable for ReturnOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<u32>("input", Self::VT_INPUT, false)?
                .finish();
            Ok(())
        }
    }
    pub struct ReturnOpArgs {
        pub input: u32,
    }
    impl<'a> Default for ReturnOpArgs {
        #[inline]
        fn default() -> Self {
            ReturnOpArgs { input: 0 }
        }
    }

    pub struct ReturnOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ReturnOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_input(&mut self, input: u32) {
            self.fbb_.push_slot::<u32>(ReturnOp::VT_INPUT, input, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ReturnOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ReturnOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ReturnOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ReturnOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ReturnOp");
            ds.field("input", &self.input());
            ds.finish()
        }
    }
    pub enum ConstRowOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    /// Zero-input source op that emits exactly one empty row.
    /// Used as the seed row for standalone CREATE/INSERT without a preceding MATCH.
    pub struct ConstRowOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for ConstRowOp<'a> {
        type Inner = ConstRowOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> ConstRowOp<'a> {
        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            ConstRowOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            _args: &'args ConstRowOpArgs,
        ) -> ::flatbuffers::WIPOffset<ConstRowOp<'bldr>> {
            let mut builder = ConstRowOpBuilder::new(_fbb);
            builder.finish()
        }
    }

    impl ::flatbuffers::Verifiable for ConstRowOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?.finish();
            Ok(())
        }
    }
    pub struct ConstRowOpArgs {}
    impl<'a> Default for ConstRowOpArgs {
        #[inline]
        fn default() -> Self {
            ConstRowOpArgs {}
        }
    }

    pub struct ConstRowOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ConstRowOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ConstRowOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ConstRowOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<ConstRowOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for ConstRowOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("ConstRowOp");
            ds.finish()
        }
    }
    pub enum PlanOpOffset {}
    #[derive(Copy, Clone, PartialEq)]

    pub struct PlanOp<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for PlanOp<'a> {
        type Inner = PlanOp<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> PlanOp<'a> {
        pub const VT_NODE_TYPE: ::flatbuffers::VOffsetT = 4;
        pub const VT_NODE: ::flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            PlanOp { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args PlanOpArgs,
        ) -> ::flatbuffers::WIPOffset<PlanOp<'bldr>> {
            let mut builder = PlanOpBuilder::new(_fbb);
            if let Some(x) = args.node {
                builder.add_node(x);
            }
            builder.add_node_type(args.node_type);
            builder.finish()
        }

        #[inline]
        pub fn node_type(&self) -> OpNode {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<OpNode>(PlanOp::VT_NODE_TYPE, Some(OpNode::NONE))
                    .unwrap()
            }
        }
        #[inline]
        pub fn node(&self) -> Option<::flatbuffers::Table<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                        PlanOp::VT_NODE,
                        None,
                    )
            }
        }
        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_scan_nodes_op(&self) -> Option<ScanNodesOp<'a>> {
            if self.node_type() == OpNode::ScanNodesOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ScanNodesOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_scan_rels_op(&self) -> Option<ScanRelsOp<'a>> {
            if self.node_type() == OpNode::ScanRelsOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ScanRelsOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_expand_op(&self) -> Option<ExpandOp<'a>> {
            if self.node_type() == OpNode::ExpandOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ExpandOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_optional_expand_op(&self) -> Option<OptionalExpandOp<'a>> {
            if self.node_type() == OpNode::OptionalExpandOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { OptionalExpandOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_semi_expand_op(&self) -> Option<SemiExpandOp<'a>> {
            if self.node_type() == OpNode::SemiExpandOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { SemiExpandOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_expand_var_len_op(&self) -> Option<ExpandVarLenOp<'a>> {
            if self.node_type() == OpNode::ExpandVarLenOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ExpandVarLenOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_filter_op(&self) -> Option<FilterOp<'a>> {
            if self.node_type() == OpNode::FilterOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { FilterOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_block_marker_op(&self) -> Option<BlockMarkerOp<'a>> {
            if self.node_type() == OpNode::BlockMarkerOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { BlockMarkerOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_project_op(&self) -> Option<ProjectOp<'a>> {
            if self.node_type() == OpNode::ProjectOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ProjectOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_aggregate_op(&self) -> Option<AggregateOp<'a>> {
            if self.node_type() == OpNode::AggregateOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { AggregateOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_sort_op(&self) -> Option<SortOp<'a>> {
            if self.node_type() == OpNode::SortOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { SortOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_limit_op(&self) -> Option<LimitOp<'a>> {
            if self.node_type() == OpNode::LimitOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { LimitOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_unwind_op(&self) -> Option<UnwindOp<'a>> {
            if self.node_type() == OpNode::UnwindOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { UnwindOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_path_construct_op(&self) -> Option<PathConstructOp<'a>> {
            if self.node_type() == OpNode::PathConstructOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { PathConstructOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_union_op(&self) -> Option<UnionOp<'a>> {
            if self.node_type() == OpNode::UnionOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { UnionOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_create_node_op(&self) -> Option<CreateNodeOp<'a>> {
            if self.node_type() == OpNode::CreateNodeOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { CreateNodeOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_create_rel_op(&self) -> Option<CreateRelOp<'a>> {
            if self.node_type() == OpNode::CreateRelOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { CreateRelOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_merge_op(&self) -> Option<MergeOp<'a>> {
            if self.node_type() == OpNode::MergeOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { MergeOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_delete_op(&self) -> Option<DeleteOp<'a>> {
            if self.node_type() == OpNode::DeleteOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { DeleteOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_set_property_op(&self) -> Option<SetPropertyOp<'a>> {
            if self.node_type() == OpNode::SetPropertyOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { SetPropertyOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_remove_property_op(&self) -> Option<RemovePropertyOp<'a>> {
            if self.node_type() == OpNode::RemovePropertyOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { RemovePropertyOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_vector_scan_op(&self) -> Option<VectorScanOp<'a>> {
            if self.node_type() == OpNode::VectorScanOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { VectorScanOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_rerank_op(&self) -> Option<RerankOp<'a>> {
            if self.node_type() == OpNode::RerankOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { RerankOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_return_op(&self) -> Option<ReturnOp<'a>> {
            if self.node_type() == OpNode::ReturnOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ReturnOp::init_from_table(t) }
                })
            } else {
                None
            }
        }

        #[inline]
        #[allow(non_snake_case)]
        pub fn node_as_const_row_op(&self) -> Option<ConstRowOp<'a>> {
            if self.node_type() == OpNode::ConstRowOp {
                self.node().map(|t| {
                    // Safety:
                    // Created from a valid Table for this object
                    // Which contains a valid union in this slot
                    unsafe { ConstRowOp::init_from_table(t) }
                })
            } else {
                None
            }
        }
    }

    impl ::flatbuffers::Verifiable for PlanOp<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
     .visit_union::<OpNode, _>("node_type", Self::VT_NODE_TYPE, "node", Self::VT_NODE, false, |key, v, pos| {
        match key {
          OpNode::ScanNodesOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ScanNodesOp>>("OpNode::ScanNodesOp", pos),
          OpNode::ScanRelsOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ScanRelsOp>>("OpNode::ScanRelsOp", pos),
          OpNode::ExpandOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ExpandOp>>("OpNode::ExpandOp", pos),
          OpNode::OptionalExpandOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<OptionalExpandOp>>("OpNode::OptionalExpandOp", pos),
          OpNode::SemiExpandOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SemiExpandOp>>("OpNode::SemiExpandOp", pos),
          OpNode::ExpandVarLenOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ExpandVarLenOp>>("OpNode::ExpandVarLenOp", pos),
          OpNode::FilterOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<FilterOp>>("OpNode::FilterOp", pos),
          OpNode::BlockMarkerOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<BlockMarkerOp>>("OpNode::BlockMarkerOp", pos),
          OpNode::ProjectOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ProjectOp>>("OpNode::ProjectOp", pos),
          OpNode::AggregateOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AggregateOp>>("OpNode::AggregateOp", pos),
          OpNode::SortOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SortOp>>("OpNode::SortOp", pos),
          OpNode::LimitOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<LimitOp>>("OpNode::LimitOp", pos),
          OpNode::UnwindOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<UnwindOp>>("OpNode::UnwindOp", pos),
          OpNode::PathConstructOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<PathConstructOp>>("OpNode::PathConstructOp", pos),
          OpNode::UnionOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<UnionOp>>("OpNode::UnionOp", pos),
          OpNode::CreateNodeOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CreateNodeOp>>("OpNode::CreateNodeOp", pos),
          OpNode::CreateRelOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CreateRelOp>>("OpNode::CreateRelOp", pos),
          OpNode::MergeOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MergeOp>>("OpNode::MergeOp", pos),
          OpNode::DeleteOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<DeleteOp>>("OpNode::DeleteOp", pos),
          OpNode::SetPropertyOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SetPropertyOp>>("OpNode::SetPropertyOp", pos),
          OpNode::RemovePropertyOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RemovePropertyOp>>("OpNode::RemovePropertyOp", pos),
          OpNode::VectorScanOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<VectorScanOp>>("OpNode::VectorScanOp", pos),
          OpNode::RerankOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RerankOp>>("OpNode::RerankOp", pos),
          OpNode::ReturnOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ReturnOp>>("OpNode::ReturnOp", pos),
          OpNode::ConstRowOp => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ConstRowOp>>("OpNode::ConstRowOp", pos),
          _ => Ok(()),
        }
     })?
     .finish();
            Ok(())
        }
    }
    pub struct PlanOpArgs {
        pub node_type: OpNode,
        pub node: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
    }
    impl<'a> Default for PlanOpArgs {
        #[inline]
        fn default() -> Self {
            PlanOpArgs {
                node_type: OpNode::NONE,
                node: None,
            }
        }
    }

    pub struct PlanOpBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PlanOpBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_node_type(&mut self, node_type: OpNode) {
            self.fbb_
                .push_slot::<OpNode>(PlanOp::VT_NODE_TYPE, node_type, OpNode::NONE);
        }
        #[inline]
        pub fn add_node(&mut self, node: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(PlanOp::VT_NODE, node);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> PlanOpBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            PlanOpBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<PlanOp<'a>> {
            let o = self.fbb_.end_table(self.start_);
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for PlanOp<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("PlanOp");
            ds.field("node_type", &self.node_type());
            match self.node_type() {
                OpNode::ScanNodesOp => {
                    if let Some(x) = self.node_as_scan_nodes_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::ScanRelsOp => {
                    if let Some(x) = self.node_as_scan_rels_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::ExpandOp => {
                    if let Some(x) = self.node_as_expand_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::OptionalExpandOp => {
                    if let Some(x) = self.node_as_optional_expand_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::SemiExpandOp => {
                    if let Some(x) = self.node_as_semi_expand_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::ExpandVarLenOp => {
                    if let Some(x) = self.node_as_expand_var_len_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::FilterOp => {
                    if let Some(x) = self.node_as_filter_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::BlockMarkerOp => {
                    if let Some(x) = self.node_as_block_marker_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::ProjectOp => {
                    if let Some(x) = self.node_as_project_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::AggregateOp => {
                    if let Some(x) = self.node_as_aggregate_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::SortOp => {
                    if let Some(x) = self.node_as_sort_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::LimitOp => {
                    if let Some(x) = self.node_as_limit_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::UnwindOp => {
                    if let Some(x) = self.node_as_unwind_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::PathConstructOp => {
                    if let Some(x) = self.node_as_path_construct_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::UnionOp => {
                    if let Some(x) = self.node_as_union_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::CreateNodeOp => {
                    if let Some(x) = self.node_as_create_node_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::CreateRelOp => {
                    if let Some(x) = self.node_as_create_rel_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::MergeOp => {
                    if let Some(x) = self.node_as_merge_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::DeleteOp => {
                    if let Some(x) = self.node_as_delete_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::SetPropertyOp => {
                    if let Some(x) = self.node_as_set_property_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::RemovePropertyOp => {
                    if let Some(x) = self.node_as_remove_property_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::VectorScanOp => {
                    if let Some(x) = self.node_as_vector_scan_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::RerankOp => {
                    if let Some(x) = self.node_as_rerank_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::ReturnOp => {
                    if let Some(x) = self.node_as_return_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                OpNode::ConstRowOp => {
                    if let Some(x) = self.node_as_const_row_op() {
                        ds.field("node", &x)
                    } else {
                        ds.field(
                            "node",
                            &"InvalidFlatbuffer: Union discriminant does not match value.",
                        )
                    }
                }
                _ => {
                    let x: Option<()> = None;
                    ds.field("node", &x)
                }
            };
            ds.finish()
        }
    }
    pub enum PlexusPlanOffset {}
    #[derive(Copy, Clone, PartialEq)]

    /// Root table for a serialized Plexus query plan.
    pub struct PlexusPlan<'a> {
        pub _tab: ::flatbuffers::Table<'a>,
    }

    impl<'a> ::flatbuffers::Follow<'a> for PlexusPlan<'a> {
        type Inner = PlexusPlan<'a>;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            Self {
                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
            }
        }
    }

    impl<'a> PlexusPlan<'a> {
        pub const VT_VERSION: ::flatbuffers::VOffsetT = 4;
        pub const VT_OPS: ::flatbuffers::VOffsetT = 6;
        pub const VT_ROOT_OP: ::flatbuffers::VOffsetT = 8;

        #[inline]
        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
            PlexusPlan { _tab: table }
        }
        #[allow(unused_mut)]
        pub fn create<
            'bldr: 'args,
            'args: 'mut_bldr,
            'mut_bldr,
            A: ::flatbuffers::Allocator + 'bldr,
        >(
            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
            args: &'args PlexusPlanArgs<'args>,
        ) -> ::flatbuffers::WIPOffset<PlexusPlan<'bldr>> {
            let mut builder = PlexusPlanBuilder::new(_fbb);
            builder.add_root_op(args.root_op);
            if let Some(x) = args.ops {
                builder.add_ops(x);
            }
            if let Some(x) = args.version {
                builder.add_version(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn version(&self) -> Version<'a> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<::flatbuffers::ForwardsUOffset<Version>>(PlexusPlan::VT_VERSION, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn ops(
            &self,
        ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PlanOp<'a>>>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PlanOp>>,
                >>(PlexusPlan::VT_OPS, None)
            }
        }
        #[inline]
        pub fn root_op(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<u32>(PlexusPlan::VT_ROOT_OP, Some(0))
                    .unwrap()
            }
        }
    }

    impl ::flatbuffers::Verifiable for PlexusPlan<'_> {
        #[inline]
        fn run_verifier(
            v: &mut ::flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
            v.visit_table(pos)?
                .visit_field::<::flatbuffers::ForwardsUOffset<Version>>(
                    "version",
                    Self::VT_VERSION,
                    true,
                )?
                .visit_field::<::flatbuffers::ForwardsUOffset<
                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<PlanOp>>,
                >>("ops", Self::VT_OPS, false)?
                .visit_field::<u32>("root_op", Self::VT_ROOT_OP, false)?
                .finish();
            Ok(())
        }
    }
    pub struct PlexusPlanArgs<'a> {
        pub version: Option<::flatbuffers::WIPOffset<Version<'a>>>,
        pub ops: Option<
            ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PlanOp<'a>>>,
            >,
        >,
        pub root_op: u32,
    }
    impl<'a> Default for PlexusPlanArgs<'a> {
        #[inline]
        fn default() -> Self {
            PlexusPlanArgs {
                version: None, // required field
                ops: None,
                root_op: 0,
            }
        }
    }

    pub struct PlexusPlanBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
        fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
    }
    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PlexusPlanBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_version(&mut self, version: ::flatbuffers::WIPOffset<Version<'b>>) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<Version>>(
                    PlexusPlan::VT_VERSION,
                    version,
                );
        }
        #[inline]
        pub fn add_ops(
            &mut self,
            ops: ::flatbuffers::WIPOffset<
                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<PlanOp<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<::flatbuffers::WIPOffset<_>>(PlexusPlan::VT_OPS, ops);
        }
        #[inline]
        pub fn add_root_op(&mut self, root_op: u32) {
            self.fbb_
                .push_slot::<u32>(PlexusPlan::VT_ROOT_OP, root_op, 0);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> PlexusPlanBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            PlexusPlanBuilder {
                fbb_: _fbb,
                start_: start,
            }
        }
        #[inline]
        pub fn finish(self) -> ::flatbuffers::WIPOffset<PlexusPlan<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, PlexusPlan::VT_VERSION, "version");
            ::flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl ::core::fmt::Debug for PlexusPlan<'_> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            let mut ds = f.debug_struct("PlexusPlan");
            ds.field("version", &self.version());
            ds.field("ops", &self.ops());
            ds.field("root_op", &self.root_op());
            ds.finish()
        }
    }
    #[inline]
    /// Verifies that a buffer of bytes contains a `PlexusPlan`
    /// and returns it.
    /// Note that verification is still experimental and may not
    /// catch every error, or be maximally performant. For the
    /// previous, unchecked, behavior use
    /// `root_as_plexus_plan_unchecked`.
    pub fn root_as_plexus_plan(
        buf: &[u8],
    ) -> Result<PlexusPlan<'_>, ::flatbuffers::InvalidFlatbuffer> {
        ::flatbuffers::root::<PlexusPlan>(buf)
    }
    #[inline]
    /// Verifies that a buffer of bytes contains a size prefixed
    /// `PlexusPlan` and returns it.
    /// Note that verification is still experimental and may not
    /// catch every error, or be maximally performant. For the
    /// previous, unchecked, behavior use
    /// `size_prefixed_root_as_plexus_plan_unchecked`.
    pub fn size_prefixed_root_as_plexus_plan(
        buf: &[u8],
    ) -> Result<PlexusPlan<'_>, ::flatbuffers::InvalidFlatbuffer> {
        ::flatbuffers::size_prefixed_root::<PlexusPlan>(buf)
    }
    #[inline]
    /// Verifies, with the given options, that a buffer of bytes
    /// contains a `PlexusPlan` and returns it.
    /// Note that verification is still experimental and may not
    /// catch every error, or be maximally performant. For the
    /// previous, unchecked, behavior use
    /// `root_as_plexus_plan_unchecked`.
    pub fn root_as_plexus_plan_with_opts<'b, 'o>(
        opts: &'o ::flatbuffers::VerifierOptions,
        buf: &'b [u8],
    ) -> Result<PlexusPlan<'b>, ::flatbuffers::InvalidFlatbuffer> {
        ::flatbuffers::root_with_opts::<PlexusPlan<'b>>(opts, buf)
    }
    #[inline]
    /// Verifies, with the given verifier options, that a buffer of
    /// bytes contains a size prefixed `PlexusPlan` and returns
    /// it. Note that verification is still experimental and may not
    /// catch every error, or be maximally performant. For the
    /// previous, unchecked, behavior use
    /// `root_as_plexus_plan_unchecked`.
    pub fn size_prefixed_root_as_plexus_plan_with_opts<'b, 'o>(
        opts: &'o ::flatbuffers::VerifierOptions,
        buf: &'b [u8],
    ) -> Result<PlexusPlan<'b>, ::flatbuffers::InvalidFlatbuffer> {
        ::flatbuffers::size_prefixed_root_with_opts::<PlexusPlan<'b>>(opts, buf)
    }
    #[inline]
    /// Assumes, without verification, that a buffer of bytes contains a PlexusPlan and returns it.
    /// # Safety
    /// Callers must trust the given bytes do indeed contain a valid `PlexusPlan`.
    pub unsafe fn root_as_plexus_plan_unchecked(buf: &[u8]) -> PlexusPlan<'_> {
        unsafe { ::flatbuffers::root_unchecked::<PlexusPlan>(buf) }
    }
    #[inline]
    /// Assumes, without verification, that a buffer of bytes contains a size prefixed PlexusPlan and returns it.
    /// # Safety
    /// Callers must trust the given bytes do indeed contain a valid size prefixed `PlexusPlan`.
    pub unsafe fn size_prefixed_root_as_plexus_plan_unchecked(buf: &[u8]) -> PlexusPlan<'_> {
        unsafe { ::flatbuffers::size_prefixed_root_unchecked::<PlexusPlan>(buf) }
    }
    pub const PLEXUS_PLAN_IDENTIFIER: &str = "PLXS";

    #[inline]
    pub fn plexus_plan_buffer_has_identifier(buf: &[u8]) -> bool {
        ::flatbuffers::buffer_has_identifier(buf, PLEXUS_PLAN_IDENTIFIER, false)
    }

    #[inline]
    pub fn plexus_plan_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
        ::flatbuffers::buffer_has_identifier(buf, PLEXUS_PLAN_IDENTIFIER, true)
    }

    pub const PLEXUS_PLAN_EXTENSION: &str = "plexus";

    #[inline]
    pub fn finish_plexus_plan_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
        fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        root: ::flatbuffers::WIPOffset<PlexusPlan<'a>>,
    ) {
        fbb.finish(root, Some(PLEXUS_PLAN_IDENTIFIER));
    }

    #[inline]
    pub fn finish_size_prefixed_plexus_plan_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
        fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
        root: ::flatbuffers::WIPOffset<PlexusPlan<'a>>,
    ) {
        fbb.finish_size_prefixed(root, Some(PLEXUS_PLAN_IDENTIFIER));
    }
} // pub mod plexus