ttypes.py

Go to the documentation of this file.

#
# Autogenerated by Thrift Compiler (0.16.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
from thrift.protocol.TProtocol import TProtocolException
from thrift.TRecursive import fix_spec

import sys
import heavydb.common.ttypes
import heavydb.completion_hints.ttypes
import heavydb.serialized_result_set.ttypes
import heavydb.extension_functions.ttypes

from thrift.transport import TTransport
all_structs = []


class TExecuteMode(object):
    GPU = 1
    CPU = 2

    _VALUES_TO_NAMES = {
        1: "GPU",
        2: "CPU",
    }

    _NAMES_TO_VALUES = {
        "GPU": 1,
        "CPU": 2,
    }


class TSourceType(object):
    DELIMITED_FILE = 0
    GEO_FILE = 1
    PARQUET_FILE = 2
    RASTER_FILE = 3
    ODBC = 4

    _VALUES_TO_NAMES = {
        0: "DELIMITED_FILE",
        1: "GEO_FILE",
        2: "PARQUET_FILE",
        3: "RASTER_FILE",
        4: "ODBC",
    }

    _NAMES_TO_VALUES = {
        "DELIMITED_FILE": 0,
        "GEO_FILE": 1,
        "PARQUET_FILE": 2,
        "RASTER_FILE": 3,
        "ODBC": 4,
    }


class TPartitionDetail(object):
    DEFAULT = 0
    REPLICATED = 1
    SHARDED = 2
    OTHER = 3

    _VALUES_TO_NAMES = {
        0: "DEFAULT",
        1: "REPLICATED",
        2: "SHARDED",
        3: "OTHER",
    }

    _NAMES_TO_VALUES = {
        "DEFAULT": 0,
        "REPLICATED": 1,
        "SHARDED": 2,
        "OTHER": 3,
    }


class TGeoFileLayerContents(object):
    EMPTY = 0
    GEO = 1
    NON_GEO = 2
    UNSUPPORTED_GEO = 3

    _VALUES_TO_NAMES = {
        0: "EMPTY",
        1: "GEO",
        2: "NON_GEO",
        3: "UNSUPPORTED_GEO",
    }

    _NAMES_TO_VALUES = {
        "EMPTY": 0,
        "GEO": 1,
        "NON_GEO": 2,
        "UNSUPPORTED_GEO": 3,
    }


class TImportHeaderRow(object):
    AUTODETECT = 0
    NO_HEADER = 1
    HAS_HEADER = 2

    _VALUES_TO_NAMES = {
        0: "AUTODETECT",
        1: "NO_HEADER",
        2: "HAS_HEADER",
    }

    _NAMES_TO_VALUES = {
        "AUTODETECT": 0,
        "NO_HEADER": 1,
        "HAS_HEADER": 2,
    }


class TRole(object):
    SERVER = 0
    AGGREGATOR = 1
    LEAF = 2
    STRING_DICTIONARY = 3

    _VALUES_TO_NAMES = {
        0: "SERVER",
        1: "AGGREGATOR",
        2: "LEAF",
        3: "STRING_DICTIONARY",
    }

    _NAMES_TO_VALUES = {
        "SERVER": 0,
        "AGGREGATOR": 1,
        "LEAF": 2,
        "STRING_DICTIONARY": 3,
    }


class TTableType(object):
    DEFAULT = 0
    TEMPORARY = 1
    FOREIGN = 2
    VIEW = 3

    _VALUES_TO_NAMES = {
        0: "DEFAULT",
        1: "TEMPORARY",
        2: "FOREIGN",
        3: "VIEW",
    }

    _NAMES_TO_VALUES = {
        "DEFAULT": 0,
        "TEMPORARY": 1,
        "FOREIGN": 2,
        "VIEW": 3,
    }


class TTableRefreshUpdateType(object):
    ALL = 0
    APPEND = 1

    _VALUES_TO_NAMES = {
        0: "ALL",
        1: "APPEND",
    }

    _NAMES_TO_VALUES = {
        "ALL": 0,
        "APPEND": 1,
    }


class TTableRefreshTimingType(object):
    MANUAL = 0
    SCHEDULED = 1

    _VALUES_TO_NAMES = {
        0: "MANUAL",
        1: "SCHEDULED",
    }

    _NAMES_TO_VALUES = {
        "MANUAL": 0,
        "SCHEDULED": 1,
    }


class TTableRefreshIntervalType(object):
    NONE = 0
    HOUR = 1
    DAY = 2

    _VALUES_TO_NAMES = {
        0: "NONE",
        1: "HOUR",
        2: "DAY",
    }

    _NAMES_TO_VALUES = {
        "NONE": 0,
        "HOUR": 1,
        "DAY": 2,
    }


class TMergeType(object):
    UNION = 0
    REDUCE = 1

    _VALUES_TO_NAMES = {
        0: "UNION",
        1: "REDUCE",
    }

    _NAMES_TO_VALUES = {
        "UNION": 0,
        "REDUCE": 1,
    }


class TRasterPointType(object):
    NONE = 0
    AUTO = 1
    SMALLINT = 2
    INT = 3
    FLOAT = 4
    DOUBLE = 5
    POINT = 6

    _VALUES_TO_NAMES = {
        0: "NONE",
        1: "AUTO",
        2: "SMALLINT",
        3: "INT",
        4: "FLOAT",
        5: "DOUBLE",
        6: "POINT",
    }

    _NAMES_TO_VALUES = {
        "NONE": 0,
        "AUTO": 1,
        "SMALLINT": 2,
        "INT": 3,
        "FLOAT": 4,
        "DOUBLE": 5,
        "POINT": 6,
    }


class TRasterPointTransform(object):
    NONE = 0
    AUTO = 1
    FILE = 2
    WORLD = 3

    _VALUES_TO_NAMES = {
        0: "NONE",
        1: "AUTO",
        2: "FILE",
        3: "WORLD",
    }

    _NAMES_TO_VALUES = {
        "NONE": 0,
        "AUTO": 1,
        "FILE": 2,
        "WORLD": 3,
    }


class TQueryType(object):
    UNKNOWN = 0
    READ = 1
    WRITE = 2
    SCHEMA_READ = 3
    SCHEMA_WRITE = 4

    _VALUES_TO_NAMES = {
        0: "UNKNOWN",
        1: "READ",
        2: "WRITE",
        3: "SCHEMA_READ",
        4: "SCHEMA_WRITE",
    }

    _NAMES_TO_VALUES = {
        "UNKNOWN": 0,
        "READ": 1,
        "WRITE": 2,
        "SCHEMA_READ": 3,
        "SCHEMA_WRITE": 4,
    }


class TArrowTransport(object):
    SHARED_MEMORY = 0
    WIRE = 1

    _VALUES_TO_NAMES = {
        0: "SHARED_MEMORY",
        1: "WIRE",
    }

    _NAMES_TO_VALUES = {
        "SHARED_MEMORY": 0,
        "WIRE": 1,
    }


class TExpressionRangeType(object):
    INVALID = 0
    INTEGER = 1
    FLOAT = 2
    DOUBLE = 3

    _VALUES_TO_NAMES = {
        0: "INVALID",
        1: "INTEGER",
        2: "FLOAT",
        3: "DOUBLE",
    }

    _NAMES_TO_VALUES = {
        "INVALID": 0,
        "INTEGER": 1,
        "FLOAT": 2,
        "DOUBLE": 3,
    }


class TDBObjectType(object):
    AbstractDBObjectType = 0
    DatabaseDBObjectType = 1
    TableDBObjectType = 2
    DashboardDBObjectType = 3
    ViewDBObjectType = 4
    ServerDBObjectType = 5

    _VALUES_TO_NAMES = {
        0: "AbstractDBObjectType",
        1: "DatabaseDBObjectType",
        2: "TableDBObjectType",
        3: "DashboardDBObjectType",
        4: "ViewDBObjectType",
        5: "ServerDBObjectType",
    }

    _NAMES_TO_VALUES = {
        "AbstractDBObjectType": 0,
        "DatabaseDBObjectType": 1,
        "TableDBObjectType": 2,
        "DashboardDBObjectType": 3,
        "ViewDBObjectType": 4,
        "ServerDBObjectType": 5,
    }


class TDataSourceType(object):
    TABLE = 0

    _VALUES_TO_NAMES = {
        0: "TABLE",
    }

    _NAMES_TO_VALUES = {
        "TABLE": 0,
    }


class TDatumVal(object):
    """
    Attributes:
     - int_val
     - real_val
     - str_val
     - arr_val

    """


    def __init__(self, int_val=None, real_val=None, str_val=None, arr_val=None,):
        self.int_val = int_val
        self.real_val = real_val
        self.str_val = str_val
        self.arr_val = arr_val

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I64:
                    self.int_val = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.DOUBLE:
                    self.real_val = iprot.readDouble()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.str_val = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.arr_val = []
                    (_etype3, _size0) = iprot.readListBegin()
                    for _i4 in range(_size0):
                        _elem5 = TDatum()
                        _elem5.read(iprot)
                        self.arr_val.append(_elem5)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDatumVal')
        if self.int_val is not None:
            oprot.writeFieldBegin('int_val', TType.I64, 1)
            oprot.writeI64(self.int_val)
            oprot.writeFieldEnd()
        if self.real_val is not None:
            oprot.writeFieldBegin('real_val', TType.DOUBLE, 2)
            oprot.writeDouble(self.real_val)
            oprot.writeFieldEnd()
        if self.str_val is not None:
            oprot.writeFieldBegin('str_val', TType.STRING, 3)
            oprot.writeString(self.str_val.encode('utf-8') if sys.version_info[0] == 2 else self.str_val)
            oprot.writeFieldEnd()
        if self.arr_val is not None:
            oprot.writeFieldBegin('arr_val', TType.LIST, 4)
            oprot.writeListBegin(TType.STRUCT, len(self.arr_val))
            for iter6 in self.arr_val:
                iter6.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDatum(object):
    """
    Attributes:
     - val
     - is_null

    """


    def __init__(self, val=None, is_null=None,):
        self.val = val
        self.is_null = is_null

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.val = TDatumVal()
                    self.val.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.is_null = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDatum')
        if self.val is not None:
            oprot.writeFieldBegin('val', TType.STRUCT, 1)
            self.val.write(oprot)
            oprot.writeFieldEnd()
        if self.is_null is not None:
            oprot.writeFieldBegin('is_null', TType.BOOL, 2)
            oprot.writeBool(self.is_null)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TStringValue(object):
    """
    Attributes:
     - str_val
     - is_null

    """


    def __init__(self, str_val=None, is_null=None,):
        self.str_val = str_val
        self.is_null = is_null

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.str_val = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.is_null = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TStringValue')
        if self.str_val is not None:
            oprot.writeFieldBegin('str_val', TType.STRING, 1)
            oprot.writeString(self.str_val.encode('utf-8') if sys.version_info[0] == 2 else self.str_val)
            oprot.writeFieldEnd()
        if self.is_null is not None:
            oprot.writeFieldBegin('is_null', TType.BOOL, 2)
            oprot.writeBool(self.is_null)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TColumnType(object):
    """
    Attributes:
     - col_name
     - col_type
     - is_reserved_keyword
     - src_name
     - is_system
     - is_physical
     - col_id
     - default_value

    """


    def __init__(self, col_name=None, col_type=None, is_reserved_keyword=None, src_name=None, is_system=None, is_physical=None, col_id=None, default_value=None,):
        self.col_name = col_name
        self.col_type = col_type
        self.is_reserved_keyword = is_reserved_keyword
        self.src_name = src_name
        self.is_system = is_system
        self.is_physical = is_physical
        self.col_id = col_id
        self.default_value = default_value

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.col_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.col_type = heavydb.common.ttypes.TTypeInfo()
                    self.col_type.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.is_reserved_keyword = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.src_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.is_system = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.BOOL:
                    self.is_physical = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.I64:
                    self.col_id = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.STRING:
                    self.default_value = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TColumnType')
        if self.col_name is not None:
            oprot.writeFieldBegin('col_name', TType.STRING, 1)
            oprot.writeString(self.col_name.encode('utf-8') if sys.version_info[0] == 2 else self.col_name)
            oprot.writeFieldEnd()
        if self.col_type is not None:
            oprot.writeFieldBegin('col_type', TType.STRUCT, 2)
            self.col_type.write(oprot)
            oprot.writeFieldEnd()
        if self.is_reserved_keyword is not None:
            oprot.writeFieldBegin('is_reserved_keyword', TType.BOOL, 3)
            oprot.writeBool(self.is_reserved_keyword)
            oprot.writeFieldEnd()
        if self.src_name is not None:
            oprot.writeFieldBegin('src_name', TType.STRING, 4)
            oprot.writeString(self.src_name.encode('utf-8') if sys.version_info[0] == 2 else self.src_name)
            oprot.writeFieldEnd()
        if self.is_system is not None:
            oprot.writeFieldBegin('is_system', TType.BOOL, 5)
            oprot.writeBool(self.is_system)
            oprot.writeFieldEnd()
        if self.is_physical is not None:
            oprot.writeFieldBegin('is_physical', TType.BOOL, 6)
            oprot.writeBool(self.is_physical)
            oprot.writeFieldEnd()
        if self.col_id is not None:
            oprot.writeFieldBegin('col_id', TType.I64, 7)
            oprot.writeI64(self.col_id)
            oprot.writeFieldEnd()
        if self.default_value is not None:
            oprot.writeFieldBegin('default_value', TType.STRING, 8)
            oprot.writeString(self.default_value.encode('utf-8') if sys.version_info[0] == 2 else self.default_value)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRow(object):
    """
    Attributes:
     - cols

    """


    def __init__(self, cols=None,):
        self.cols = cols

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.cols = []
                    (_etype10, _size7) = iprot.readListBegin()
                    for _i11 in range(_size7):
                        _elem12 = TDatum()
                        _elem12.read(iprot)
                        self.cols.append(_elem12)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRow')
        if self.cols is not None:
            oprot.writeFieldBegin('cols', TType.LIST, 1)
            oprot.writeListBegin(TType.STRUCT, len(self.cols))
            for iter13 in self.cols:
                iter13.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TColumnData(object):
    """
    Attributes:
     - int_col
     - real_col
     - str_col
     - arr_col

    """


    def __init__(self, int_col=None, real_col=None, str_col=None, arr_col=None,):
        self.int_col = int_col
        self.real_col = real_col
        self.str_col = str_col
        self.arr_col = arr_col

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.int_col = []
                    (_etype17, _size14) = iprot.readListBegin()
                    for _i18 in range(_size14):
                        _elem19 = iprot.readI64()
                        self.int_col.append(_elem19)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.real_col = []
                    (_etype23, _size20) = iprot.readListBegin()
                    for _i24 in range(_size20):
                        _elem25 = iprot.readDouble()
                        self.real_col.append(_elem25)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.str_col = []
                    (_etype29, _size26) = iprot.readListBegin()
                    for _i30 in range(_size26):
                        _elem31 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                        self.str_col.append(_elem31)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.arr_col = []
                    (_etype35, _size32) = iprot.readListBegin()
                    for _i36 in range(_size32):
                        _elem37 = TColumn()
                        _elem37.read(iprot)
                        self.arr_col.append(_elem37)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TColumnData')
        if self.int_col is not None:
            oprot.writeFieldBegin('int_col', TType.LIST, 1)
            oprot.writeListBegin(TType.I64, len(self.int_col))
            for iter38 in self.int_col:
                oprot.writeI64(iter38)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.real_col is not None:
            oprot.writeFieldBegin('real_col', TType.LIST, 2)
            oprot.writeListBegin(TType.DOUBLE, len(self.real_col))
            for iter39 in self.real_col:
                oprot.writeDouble(iter39)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.str_col is not None:
            oprot.writeFieldBegin('str_col', TType.LIST, 3)
            oprot.writeListBegin(TType.STRING, len(self.str_col))
            for iter40 in self.str_col:
                oprot.writeString(iter40.encode('utf-8') if sys.version_info[0] == 2 else iter40)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.arr_col is not None:
            oprot.writeFieldBegin('arr_col', TType.LIST, 4)
            oprot.writeListBegin(TType.STRUCT, len(self.arr_col))
            for iter41 in self.arr_col:
                iter41.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TColumn(object):
    """
    Attributes:
     - data
     - nulls

    """


    def __init__(self, data=None, nulls=None,):
        self.data = data
        self.nulls = nulls

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.data = TColumnData()
                    self.data.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.nulls = []
                    (_etype45, _size42) = iprot.readListBegin()
                    for _i46 in range(_size42):
                        _elem47 = iprot.readBool()
                        self.nulls.append(_elem47)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TColumn')
        if self.data is not None:
            oprot.writeFieldBegin('data', TType.STRUCT, 1)
            self.data.write(oprot)
            oprot.writeFieldEnd()
        if self.nulls is not None:
            oprot.writeFieldBegin('nulls', TType.LIST, 2)
            oprot.writeListBegin(TType.BOOL, len(self.nulls))
            for iter48 in self.nulls:
                oprot.writeBool(iter48)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TStringRow(object):
    """
    Attributes:
     - cols

    """


    def __init__(self, cols=None,):
        self.cols = cols

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.cols = []
                    (_etype52, _size49) = iprot.readListBegin()
                    for _i53 in range(_size49):
                        _elem54 = TStringValue()
                        _elem54.read(iprot)
                        self.cols.append(_elem54)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TStringRow')
        if self.cols is not None:
            oprot.writeFieldBegin('cols', TType.LIST, 1)
            oprot.writeListBegin(TType.STRUCT, len(self.cols))
            for iter55 in self.cols:
                iter55.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TKrb5Session(object):
    """
    Attributes:
     - sessionId
     - krbToken

    """


    def __init__(self, sessionId=None, krbToken=None,):
        self.sessionId = sessionId
        self.krbToken = krbToken

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.sessionId = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.krbToken = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TKrb5Session')
        if self.sessionId is not None:
            oprot.writeFieldBegin('sessionId', TType.STRING, 1)
            oprot.writeString(self.sessionId.encode('utf-8') if sys.version_info[0] == 2 else self.sessionId)
            oprot.writeFieldEnd()
        if self.krbToken is not None:
            oprot.writeFieldBegin('krbToken', TType.STRING, 2)
            oprot.writeString(self.krbToken.encode('utf-8') if sys.version_info[0] == 2 else self.krbToken)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TStepResult(object):
    """
    Attributes:
     - serialized_rows
     - execution_finished
     - merge_type
     - sharded
     - row_desc
     - node_id

    """


    def __init__(self, serialized_rows=None, execution_finished=None, merge_type=None, sharded=None, row_desc=None, node_id=None,):
        self.serialized_rows = serialized_rows
        self.execution_finished = execution_finished
        self.merge_type = merge_type
        self.sharded = sharded
        self.row_desc = row_desc
        self.node_id = node_id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.serialized_rows = heavydb.serialized_result_set.ttypes.TSerializedRows()
                    self.serialized_rows.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.execution_finished = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.merge_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.sharded = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.LIST:
                    self.row_desc = []
                    (_etype59, _size56) = iprot.readListBegin()
                    for _i60 in range(_size56):
                        _elem61 = TColumnType()
                        _elem61.read(iprot)
                        self.row_desc.append(_elem61)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I32:
                    self.node_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TStepResult')
        if self.serialized_rows is not None:
            oprot.writeFieldBegin('serialized_rows', TType.STRUCT, 1)
            self.serialized_rows.write(oprot)
            oprot.writeFieldEnd()
        if self.execution_finished is not None:
            oprot.writeFieldBegin('execution_finished', TType.BOOL, 2)
            oprot.writeBool(self.execution_finished)
            oprot.writeFieldEnd()
        if self.merge_type is not None:
            oprot.writeFieldBegin('merge_type', TType.I32, 3)
            oprot.writeI32(self.merge_type)
            oprot.writeFieldEnd()
        if self.sharded is not None:
            oprot.writeFieldBegin('sharded', TType.BOOL, 4)
            oprot.writeBool(self.sharded)
            oprot.writeFieldEnd()
        if self.row_desc is not None:
            oprot.writeFieldBegin('row_desc', TType.LIST, 5)
            oprot.writeListBegin(TType.STRUCT, len(self.row_desc))
            for iter62 in self.row_desc:
                iter62.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.node_id is not None:
            oprot.writeFieldBegin('node_id', TType.I32, 6)
            oprot.writeI32(self.node_id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRowSet(object):
    """
    Attributes:
     - row_desc
     - rows
     - columns
     - is_columnar

    """


    def __init__(self, row_desc=None, rows=None, columns=None, is_columnar=None,):
        self.row_desc = row_desc
        self.rows = rows
        self.columns = columns
        self.is_columnar = is_columnar

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.row_desc = []
                    (_etype66, _size63) = iprot.readListBegin()
                    for _i67 in range(_size63):
                        _elem68 = TColumnType()
                        _elem68.read(iprot)
                        self.row_desc.append(_elem68)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.rows = []
                    (_etype72, _size69) = iprot.readListBegin()
                    for _i73 in range(_size69):
                        _elem74 = TRow()
                        _elem74.read(iprot)
                        self.rows.append(_elem74)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.columns = []
                    (_etype78, _size75) = iprot.readListBegin()
                    for _i79 in range(_size75):
                        _elem80 = TColumn()
                        _elem80.read(iprot)
                        self.columns.append(_elem80)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.is_columnar = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRowSet')
        if self.row_desc is not None:
            oprot.writeFieldBegin('row_desc', TType.LIST, 1)
            oprot.writeListBegin(TType.STRUCT, len(self.row_desc))
            for iter81 in self.row_desc:
                iter81.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.rows is not None:
            oprot.writeFieldBegin('rows', TType.LIST, 2)
            oprot.writeListBegin(TType.STRUCT, len(self.rows))
            for iter82 in self.rows:
                iter82.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.columns is not None:
            oprot.writeFieldBegin('columns', TType.LIST, 3)
            oprot.writeListBegin(TType.STRUCT, len(self.columns))
            for iter83 in self.columns:
                iter83.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.is_columnar is not None:
            oprot.writeFieldBegin('is_columnar', TType.BOOL, 4)
            oprot.writeBool(self.is_columnar)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TQueryResult(object):
    """
    Attributes:
     - row_set
     - execution_time_ms
     - total_time_ms
     - nonce
     - debug
     - success
     - query_type

    """


    def __init__(self, row_set=None, execution_time_ms=None, total_time_ms=None, nonce=None, debug=None, success=True, query_type=0,):
        self.row_set = row_set
        self.execution_time_ms = execution_time_ms
        self.total_time_ms = total_time_ms
        self.nonce = nonce
        self.debug = debug
        self.success = success
        self.query_type = query_type

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.row_set = TRowSet()
                    self.row_set.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.execution_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.total_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.nonce = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.debug = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.BOOL:
                    self.success = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.I32:
                    self.query_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TQueryResult')
        if self.row_set is not None:
            oprot.writeFieldBegin('row_set', TType.STRUCT, 1)
            self.row_set.write(oprot)
            oprot.writeFieldEnd()
        if self.execution_time_ms is not None:
            oprot.writeFieldBegin('execution_time_ms', TType.I64, 2)
            oprot.writeI64(self.execution_time_ms)
            oprot.writeFieldEnd()
        if self.total_time_ms is not None:
            oprot.writeFieldBegin('total_time_ms', TType.I64, 3)
            oprot.writeI64(self.total_time_ms)
            oprot.writeFieldEnd()
        if self.nonce is not None:
            oprot.writeFieldBegin('nonce', TType.STRING, 4)
            oprot.writeString(self.nonce.encode('utf-8') if sys.version_info[0] == 2 else self.nonce)
            oprot.writeFieldEnd()
        if self.debug is not None:
            oprot.writeFieldBegin('debug', TType.STRING, 5)
            oprot.writeString(self.debug.encode('utf-8') if sys.version_info[0] == 2 else self.debug)
            oprot.writeFieldEnd()
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.BOOL, 6)
            oprot.writeBool(self.success)
            oprot.writeFieldEnd()
        if self.query_type is not None:
            oprot.writeFieldBegin('query_type', TType.I32, 7)
            oprot.writeI32(self.query_type)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDataFrame(object):
    """
    Attributes:
     - sm_handle
     - sm_size
     - df_handle
     - df_size
     - execution_time_ms
     - arrow_conversion_time_ms
     - df_buffer

    """


    def __init__(self, sm_handle=None, sm_size=None, df_handle=None, df_size=None, execution_time_ms=None, arrow_conversion_time_ms=None, df_buffer=None,):
        self.sm_handle = sm_handle
        self.sm_size = sm_size
        self.df_handle = df_handle
        self.df_size = df_size
        self.execution_time_ms = execution_time_ms
        self.arrow_conversion_time_ms = arrow_conversion_time_ms
        self.df_buffer = df_buffer

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.sm_handle = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.sm_size = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.df_handle = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.df_size = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.execution_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I64:
                    self.arrow_conversion_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.df_buffer = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDataFrame')
        if self.sm_handle is not None:
            oprot.writeFieldBegin('sm_handle', TType.STRING, 1)
            oprot.writeBinary(self.sm_handle)
            oprot.writeFieldEnd()
        if self.sm_size is not None:
            oprot.writeFieldBegin('sm_size', TType.I64, 2)
            oprot.writeI64(self.sm_size)
            oprot.writeFieldEnd()
        if self.df_handle is not None:
            oprot.writeFieldBegin('df_handle', TType.STRING, 3)
            oprot.writeBinary(self.df_handle)
            oprot.writeFieldEnd()
        if self.df_size is not None:
            oprot.writeFieldBegin('df_size', TType.I64, 4)
            oprot.writeI64(self.df_size)
            oprot.writeFieldEnd()
        if self.execution_time_ms is not None:
            oprot.writeFieldBegin('execution_time_ms', TType.I64, 5)
            oprot.writeI64(self.execution_time_ms)
            oprot.writeFieldEnd()
        if self.arrow_conversion_time_ms is not None:
            oprot.writeFieldBegin('arrow_conversion_time_ms', TType.I64, 6)
            oprot.writeI64(self.arrow_conversion_time_ms)
            oprot.writeFieldEnd()
        if self.df_buffer is not None:
            oprot.writeFieldBegin('df_buffer', TType.STRING, 7)
            oprot.writeBinary(self.df_buffer)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDBInfo(object):
    """
    Attributes:
     - db_name
     - db_owner

    """


    def __init__(self, db_name=None, db_owner=None,):
        self.db_name = db_name
        self.db_owner = db_owner

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.db_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.db_owner = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDBInfo')
        if self.db_name is not None:
            oprot.writeFieldBegin('db_name', TType.STRING, 1)
            oprot.writeString(self.db_name.encode('utf-8') if sys.version_info[0] == 2 else self.db_name)
            oprot.writeFieldEnd()
        if self.db_owner is not None:
            oprot.writeFieldBegin('db_owner', TType.STRING, 2)
            oprot.writeString(self.db_owner.encode('utf-8') if sys.version_info[0] == 2 else self.db_owner)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDBException(TException):
    """
    Attributes:
     - error_msg

    """


    def __init__(self, error_msg=None,):
        super(TDBException, self).__setattr__('error_msg', error_msg)

    def __setattr__(self, *args):
        raise TypeError("can't modify immutable instance")

    def __delattr__(self, *args):
        raise TypeError("can't modify immutable instance")

    def __hash__(self):
        return hash(self.__class__) ^ hash((self.error_msg, ))

    @classmethod
    def read(cls, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and cls.thrift_spec is not None:
            return iprot._fast_decode(None, iprot, [cls, cls.thrift_spec])
        iprot.readStructBegin()
        error_msg = None
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    error_msg = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()
        return cls(
            error_msg=error_msg,
        )

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDBException')
        if self.error_msg is not None:
            oprot.writeFieldBegin('error_msg', TType.STRING, 1)
            oprot.writeString(self.error_msg.encode('utf-8') if sys.version_info[0] == 2 else self.error_msg)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __str__(self):
        return repr(self)

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TCopyParams(object):
    """
    Attributes:
     - delimiter
     - null_str
     - has_header
     - quoted
     - quote
     - escape
     - line_delim
     - array_delim
     - array_begin
     - array_end
     - threads
     - source_type
     - s3_access_key
     - s3_secret_key
     - s3_region
     - geo_coords_encoding
     - geo_coords_comp_param
     - geo_coords_type
     - geo_coords_srid
     - sanitize_column_names
     - geo_layer_name
     - s3_endpoint
     - geo_assign_render_groups
     - geo_explode_collections
     - source_srid
     - s3_session_token
     - raster_point_type
     - raster_import_bands
     - raster_scanlines_per_thread
     - raster_point_transform
     - raster_point_compute_angle
     - raster_import_dimensions
     - odbc_dsn
     - odbc_connection_string
     - odbc_sql_select
     - odbc_sql_order_by
     - odbc_username
     - odbc_password
     - odbc_credential_string
     - add_metadata_columns
     - trim_spaces
     - geo_validate_geometry

    """


    def __init__(self, delimiter=None, null_str=None, has_header=0, quoted=None, quote=None, escape=None, line_delim=None, array_delim=None, array_begin=None, array_end=None, threads=None, source_type=0, s3_access_key=None, s3_secret_key=None, s3_region=None, geo_coords_encoding=6, geo_coords_comp_param=32, geo_coords_type=18, geo_coords_srid=4326, sanitize_column_names=True, geo_layer_name=None, s3_endpoint=None, geo_assign_render_groups=False, geo_explode_collections=False, source_srid=0, s3_session_token=None, raster_point_type=1, raster_import_bands=None, raster_scanlines_per_thread=None, raster_point_transform=1, raster_point_compute_angle=False, raster_import_dimensions=None, odbc_dsn=None, odbc_connection_string=None, odbc_sql_select=None, odbc_sql_order_by=None, odbc_username=None, odbc_password=None, odbc_credential_string=None, add_metadata_columns=None, trim_spaces=True, geo_validate_geometry=False,):
        self.delimiter = delimiter
        self.null_str = null_str
        self.has_header = has_header
        self.quoted = quoted
        self.quote = quote
        self.escape = escape
        self.line_delim = line_delim
        self.array_delim = array_delim
        self.array_begin = array_begin
        self.array_end = array_end
        self.threads = threads
        self.source_type = source_type
        self.s3_access_key = s3_access_key
        self.s3_secret_key = s3_secret_key
        self.s3_region = s3_region
        self.geo_coords_encoding = geo_coords_encoding
        self.geo_coords_comp_param = geo_coords_comp_param
        self.geo_coords_type = geo_coords_type
        self.geo_coords_srid = geo_coords_srid
        self.sanitize_column_names = sanitize_column_names
        self.geo_layer_name = geo_layer_name
        self.s3_endpoint = s3_endpoint
        self.geo_assign_render_groups = geo_assign_render_groups
        self.geo_explode_collections = geo_explode_collections
        self.source_srid = source_srid
        self.s3_session_token = s3_session_token
        self.raster_point_type = raster_point_type
        self.raster_import_bands = raster_import_bands
        self.raster_scanlines_per_thread = raster_scanlines_per_thread
        self.raster_point_transform = raster_point_transform
        self.raster_point_compute_angle = raster_point_compute_angle
        self.raster_import_dimensions = raster_import_dimensions
        self.odbc_dsn = odbc_dsn
        self.odbc_connection_string = odbc_connection_string
        self.odbc_sql_select = odbc_sql_select
        self.odbc_sql_order_by = odbc_sql_order_by
        self.odbc_username = odbc_username
        self.odbc_password = odbc_password
        self.odbc_credential_string = odbc_credential_string
        self.add_metadata_columns = add_metadata_columns
        self.trim_spaces = trim_spaces
        self.geo_validate_geometry = geo_validate_geometry

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.delimiter = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.null_str = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.has_header = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.quoted = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.quote = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.escape = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.line_delim = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.STRING:
                    self.array_delim = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.STRING:
                    self.array_begin = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 10:
                if ftype == TType.STRING:
                    self.array_end = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 11:
                if ftype == TType.I32:
                    self.threads = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 12:
                if ftype == TType.I32:
                    self.source_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 13:
                if ftype == TType.STRING:
                    self.s3_access_key = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 14:
                if ftype == TType.STRING:
                    self.s3_secret_key = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 15:
                if ftype == TType.STRING:
                    self.s3_region = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 16:
                if ftype == TType.I32:
                    self.geo_coords_encoding = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 17:
                if ftype == TType.I32:
                    self.geo_coords_comp_param = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 18:
                if ftype == TType.I32:
                    self.geo_coords_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 19:
                if ftype == TType.I32:
                    self.geo_coords_srid = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 20:
                if ftype == TType.BOOL:
                    self.sanitize_column_names = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 21:
                if ftype == TType.STRING:
                    self.geo_layer_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 22:
                if ftype == TType.STRING:
                    self.s3_endpoint = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 23:
                if ftype == TType.BOOL:
                    self.geo_assign_render_groups = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 24:
                if ftype == TType.BOOL:
                    self.geo_explode_collections = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 25:
                if ftype == TType.I32:
                    self.source_srid = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 26:
                if ftype == TType.STRING:
                    self.s3_session_token = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 27:
                if ftype == TType.I32:
                    self.raster_point_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 28:
                if ftype == TType.STRING:
                    self.raster_import_bands = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 29:
                if ftype == TType.I32:
                    self.raster_scanlines_per_thread = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 30:
                if ftype == TType.I32:
                    self.raster_point_transform = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 31:
                if ftype == TType.BOOL:
                    self.raster_point_compute_angle = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 32:
                if ftype == TType.STRING:
                    self.raster_import_dimensions = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 33:
                if ftype == TType.STRING:
                    self.odbc_dsn = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 34:
                if ftype == TType.STRING:
                    self.odbc_connection_string = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 35:
                if ftype == TType.STRING:
                    self.odbc_sql_select = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 36:
                if ftype == TType.STRING:
                    self.odbc_sql_order_by = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 37:
                if ftype == TType.STRING:
                    self.odbc_username = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 38:
                if ftype == TType.STRING:
                    self.odbc_password = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 39:
                if ftype == TType.STRING:
                    self.odbc_credential_string = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 40:
                if ftype == TType.STRING:
                    self.add_metadata_columns = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 41:
                if ftype == TType.BOOL:
                    self.trim_spaces = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 42:
                if ftype == TType.BOOL:
                    self.geo_validate_geometry = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TCopyParams')
        if self.delimiter is not None:
            oprot.writeFieldBegin('delimiter', TType.STRING, 1)
            oprot.writeString(self.delimiter.encode('utf-8') if sys.version_info[0] == 2 else self.delimiter)
            oprot.writeFieldEnd()
        if self.null_str is not None:
            oprot.writeFieldBegin('null_str', TType.STRING, 2)
            oprot.writeString(self.null_str.encode('utf-8') if sys.version_info[0] == 2 else self.null_str)
            oprot.writeFieldEnd()
        if self.has_header is not None:
            oprot.writeFieldBegin('has_header', TType.I32, 3)
            oprot.writeI32(self.has_header)
            oprot.writeFieldEnd()
        if self.quoted is not None:
            oprot.writeFieldBegin('quoted', TType.BOOL, 4)
            oprot.writeBool(self.quoted)
            oprot.writeFieldEnd()
        if self.quote is not None:
            oprot.writeFieldBegin('quote', TType.STRING, 5)
            oprot.writeString(self.quote.encode('utf-8') if sys.version_info[0] == 2 else self.quote)
            oprot.writeFieldEnd()
        if self.escape is not None:
            oprot.writeFieldBegin('escape', TType.STRING, 6)
            oprot.writeString(self.escape.encode('utf-8') if sys.version_info[0] == 2 else self.escape)
            oprot.writeFieldEnd()
        if self.line_delim is not None:
            oprot.writeFieldBegin('line_delim', TType.STRING, 7)
            oprot.writeString(self.line_delim.encode('utf-8') if sys.version_info[0] == 2 else self.line_delim)
            oprot.writeFieldEnd()
        if self.array_delim is not None:
            oprot.writeFieldBegin('array_delim', TType.STRING, 8)
            oprot.writeString(self.array_delim.encode('utf-8') if sys.version_info[0] == 2 else self.array_delim)
            oprot.writeFieldEnd()
        if self.array_begin is not None:
            oprot.writeFieldBegin('array_begin', TType.STRING, 9)
            oprot.writeString(self.array_begin.encode('utf-8') if sys.version_info[0] == 2 else self.array_begin)
            oprot.writeFieldEnd()
        if self.array_end is not None:
            oprot.writeFieldBegin('array_end', TType.STRING, 10)
            oprot.writeString(self.array_end.encode('utf-8') if sys.version_info[0] == 2 else self.array_end)
            oprot.writeFieldEnd()
        if self.threads is not None:
            oprot.writeFieldBegin('threads', TType.I32, 11)
            oprot.writeI32(self.threads)
            oprot.writeFieldEnd()
        if self.source_type is not None:
            oprot.writeFieldBegin('source_type', TType.I32, 12)
            oprot.writeI32(self.source_type)
            oprot.writeFieldEnd()
        if self.s3_access_key is not None:
            oprot.writeFieldBegin('s3_access_key', TType.STRING, 13)
            oprot.writeString(self.s3_access_key.encode('utf-8') if sys.version_info[0] == 2 else self.s3_access_key)
            oprot.writeFieldEnd()
        if self.s3_secret_key is not None:
            oprot.writeFieldBegin('s3_secret_key', TType.STRING, 14)
            oprot.writeString(self.s3_secret_key.encode('utf-8') if sys.version_info[0] == 2 else self.s3_secret_key)
            oprot.writeFieldEnd()
        if self.s3_region is not None:
            oprot.writeFieldBegin('s3_region', TType.STRING, 15)
            oprot.writeString(self.s3_region.encode('utf-8') if sys.version_info[0] == 2 else self.s3_region)
            oprot.writeFieldEnd()
        if self.geo_coords_encoding is not None:
            oprot.writeFieldBegin('geo_coords_encoding', TType.I32, 16)
            oprot.writeI32(self.geo_coords_encoding)
            oprot.writeFieldEnd()
        if self.geo_coords_comp_param is not None:
            oprot.writeFieldBegin('geo_coords_comp_param', TType.I32, 17)
            oprot.writeI32(self.geo_coords_comp_param)
            oprot.writeFieldEnd()
        if self.geo_coords_type is not None:
            oprot.writeFieldBegin('geo_coords_type', TType.I32, 18)
            oprot.writeI32(self.geo_coords_type)
            oprot.writeFieldEnd()
        if self.geo_coords_srid is not None:
            oprot.writeFieldBegin('geo_coords_srid', TType.I32, 19)
            oprot.writeI32(self.geo_coords_srid)
            oprot.writeFieldEnd()
        if self.sanitize_column_names is not None:
            oprot.writeFieldBegin('sanitize_column_names', TType.BOOL, 20)
            oprot.writeBool(self.sanitize_column_names)
            oprot.writeFieldEnd()
        if self.geo_layer_name is not None:
            oprot.writeFieldBegin('geo_layer_name', TType.STRING, 21)
            oprot.writeString(self.geo_layer_name.encode('utf-8') if sys.version_info[0] == 2 else self.geo_layer_name)
            oprot.writeFieldEnd()
        if self.s3_endpoint is not None:
            oprot.writeFieldBegin('s3_endpoint', TType.STRING, 22)
            oprot.writeString(self.s3_endpoint.encode('utf-8') if sys.version_info[0] == 2 else self.s3_endpoint)
            oprot.writeFieldEnd()
        if self.geo_assign_render_groups is not None:
            oprot.writeFieldBegin('geo_assign_render_groups', TType.BOOL, 23)
            oprot.writeBool(self.geo_assign_render_groups)
            oprot.writeFieldEnd()
        if self.geo_explode_collections is not None:
            oprot.writeFieldBegin('geo_explode_collections', TType.BOOL, 24)
            oprot.writeBool(self.geo_explode_collections)
            oprot.writeFieldEnd()
        if self.source_srid is not None:
            oprot.writeFieldBegin('source_srid', TType.I32, 25)
            oprot.writeI32(self.source_srid)
            oprot.writeFieldEnd()
        if self.s3_session_token is not None:
            oprot.writeFieldBegin('s3_session_token', TType.STRING, 26)
            oprot.writeString(self.s3_session_token.encode('utf-8') if sys.version_info[0] == 2 else self.s3_session_token)
            oprot.writeFieldEnd()
        if self.raster_point_type is not None:
            oprot.writeFieldBegin('raster_point_type', TType.I32, 27)
            oprot.writeI32(self.raster_point_type)
            oprot.writeFieldEnd()
        if self.raster_import_bands is not None:
            oprot.writeFieldBegin('raster_import_bands', TType.STRING, 28)
            oprot.writeString(self.raster_import_bands.encode('utf-8') if sys.version_info[0] == 2 else self.raster_import_bands)
            oprot.writeFieldEnd()
        if self.raster_scanlines_per_thread is not None:
            oprot.writeFieldBegin('raster_scanlines_per_thread', TType.I32, 29)
            oprot.writeI32(self.raster_scanlines_per_thread)
            oprot.writeFieldEnd()
        if self.raster_point_transform is not None:
            oprot.writeFieldBegin('raster_point_transform', TType.I32, 30)
            oprot.writeI32(self.raster_point_transform)
            oprot.writeFieldEnd()
        if self.raster_point_compute_angle is not None:
            oprot.writeFieldBegin('raster_point_compute_angle', TType.BOOL, 31)
            oprot.writeBool(self.raster_point_compute_angle)
            oprot.writeFieldEnd()
        if self.raster_import_dimensions is not None:
            oprot.writeFieldBegin('raster_import_dimensions', TType.STRING, 32)
            oprot.writeString(self.raster_import_dimensions.encode('utf-8') if sys.version_info[0] == 2 else self.raster_import_dimensions)
            oprot.writeFieldEnd()
        if self.odbc_dsn is not None:
            oprot.writeFieldBegin('odbc_dsn', TType.STRING, 33)
            oprot.writeString(self.odbc_dsn.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_dsn)
            oprot.writeFieldEnd()
        if self.odbc_connection_string is not None:
            oprot.writeFieldBegin('odbc_connection_string', TType.STRING, 34)
            oprot.writeString(self.odbc_connection_string.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_connection_string)
            oprot.writeFieldEnd()
        if self.odbc_sql_select is not None:
            oprot.writeFieldBegin('odbc_sql_select', TType.STRING, 35)
            oprot.writeString(self.odbc_sql_select.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_sql_select)
            oprot.writeFieldEnd()
        if self.odbc_sql_order_by is not None:
            oprot.writeFieldBegin('odbc_sql_order_by', TType.STRING, 36)
            oprot.writeString(self.odbc_sql_order_by.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_sql_order_by)
            oprot.writeFieldEnd()
        if self.odbc_username is not None:
            oprot.writeFieldBegin('odbc_username', TType.STRING, 37)
            oprot.writeString(self.odbc_username.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_username)
            oprot.writeFieldEnd()
        if self.odbc_password is not None:
            oprot.writeFieldBegin('odbc_password', TType.STRING, 38)
            oprot.writeString(self.odbc_password.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_password)
            oprot.writeFieldEnd()
        if self.odbc_credential_string is not None:
            oprot.writeFieldBegin('odbc_credential_string', TType.STRING, 39)
            oprot.writeString(self.odbc_credential_string.encode('utf-8') if sys.version_info[0] == 2 else self.odbc_credential_string)
            oprot.writeFieldEnd()
        if self.add_metadata_columns is not None:
            oprot.writeFieldBegin('add_metadata_columns', TType.STRING, 40)
            oprot.writeString(self.add_metadata_columns.encode('utf-8') if sys.version_info[0] == 2 else self.add_metadata_columns)
            oprot.writeFieldEnd()
        if self.trim_spaces is not None:
            oprot.writeFieldBegin('trim_spaces', TType.BOOL, 41)
            oprot.writeBool(self.trim_spaces)
            oprot.writeFieldEnd()
        if self.geo_validate_geometry is not None:
            oprot.writeFieldBegin('geo_validate_geometry', TType.BOOL, 42)
            oprot.writeBool(self.geo_validate_geometry)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TCreateParams(object):
    """
    Attributes:
     - is_replicated

    """


    def __init__(self, is_replicated=None,):
        self.is_replicated = is_replicated

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.is_replicated = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TCreateParams')
        if self.is_replicated is not None:
            oprot.writeFieldBegin('is_replicated', TType.BOOL, 1)
            oprot.writeBool(self.is_replicated)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDetectResult(object):
    """
    Attributes:
     - row_set
     - copy_params

    """


    def __init__(self, row_set=None, copy_params=None,):
        self.row_set = row_set
        self.copy_params = copy_params

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.row_set = TRowSet()
                    self.row_set.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.copy_params = TCopyParams()
                    self.copy_params.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDetectResult')
        if self.row_set is not None:
            oprot.writeFieldBegin('row_set', TType.STRUCT, 1)
            self.row_set.write(oprot)
            oprot.writeFieldEnd()
        if self.copy_params is not None:
            oprot.writeFieldBegin('copy_params', TType.STRUCT, 2)
            self.copy_params.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TImportStatus(object):
    """
    Attributes:
     - elapsed
     - rows_completed
     - rows_estimated
     - rows_rejected

    """


    def __init__(self, elapsed=None, rows_completed=None, rows_estimated=None, rows_rejected=None,):
        self.elapsed = elapsed
        self.rows_completed = rows_completed
        self.rows_estimated = rows_estimated
        self.rows_rejected = rows_rejected

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I64:
                    self.elapsed = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.rows_completed = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.rows_estimated = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.rows_rejected = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TImportStatus')
        if self.elapsed is not None:
            oprot.writeFieldBegin('elapsed', TType.I64, 1)
            oprot.writeI64(self.elapsed)
            oprot.writeFieldEnd()
        if self.rows_completed is not None:
            oprot.writeFieldBegin('rows_completed', TType.I64, 2)
            oprot.writeI64(self.rows_completed)
            oprot.writeFieldEnd()
        if self.rows_estimated is not None:
            oprot.writeFieldBegin('rows_estimated', TType.I64, 3)
            oprot.writeI64(self.rows_estimated)
            oprot.writeFieldEnd()
        if self.rows_rejected is not None:
            oprot.writeFieldBegin('rows_rejected', TType.I64, 4)
            oprot.writeI64(self.rows_rejected)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TFrontendView(object):
    """
    Attributes:
     - view_name
     - view_state
     - image_hash
     - update_time
     - view_metadata

    """


    def __init__(self, view_name=None, view_state=None, image_hash=None, update_time=None, view_metadata=None,):
        self.view_name = view_name
        self.view_state = view_state
        self.image_hash = image_hash
        self.update_time = update_time
        self.view_metadata = view_metadata

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.view_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.view_state = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.image_hash = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.update_time = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.view_metadata = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TFrontendView')
        if self.view_name is not None:
            oprot.writeFieldBegin('view_name', TType.STRING, 1)
            oprot.writeString(self.view_name.encode('utf-8') if sys.version_info[0] == 2 else self.view_name)
            oprot.writeFieldEnd()
        if self.view_state is not None:
            oprot.writeFieldBegin('view_state', TType.STRING, 2)
            oprot.writeString(self.view_state.encode('utf-8') if sys.version_info[0] == 2 else self.view_state)
            oprot.writeFieldEnd()
        if self.image_hash is not None:
            oprot.writeFieldBegin('image_hash', TType.STRING, 3)
            oprot.writeString(self.image_hash.encode('utf-8') if sys.version_info[0] == 2 else self.image_hash)
            oprot.writeFieldEnd()
        if self.update_time is not None:
            oprot.writeFieldBegin('update_time', TType.STRING, 4)
            oprot.writeString(self.update_time.encode('utf-8') if sys.version_info[0] == 2 else self.update_time)
            oprot.writeFieldEnd()
        if self.view_metadata is not None:
            oprot.writeFieldBegin('view_metadata', TType.STRING, 5)
            oprot.writeString(self.view_metadata.encode('utf-8') if sys.version_info[0] == 2 else self.view_metadata)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TServerStatus(object):
    """
    Attributes:
     - read_only
     - version
     - rendering_enabled
     - start_time
     - edition
     - host_name
     - poly_rendering_enabled
     - role
     - renderer_status_json
     - host_id

    """


    def __init__(self, read_only=None, version=None, rendering_enabled=None, start_time=None, edition=None, host_name=None, poly_rendering_enabled=None, role=None, renderer_status_json=None, host_id=None,):
        self.read_only = read_only
        self.version = version
        self.rendering_enabled = rendering_enabled
        self.start_time = start_time
        self.edition = edition
        self.host_name = host_name
        self.poly_rendering_enabled = poly_rendering_enabled
        self.role = role
        self.renderer_status_json = renderer_status_json
        self.host_id = host_id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.read_only = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.version = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.rendering_enabled = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.start_time = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.edition = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.host_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.BOOL:
                    self.poly_rendering_enabled = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.I32:
                    self.role = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.STRING:
                    self.renderer_status_json = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 10:
                if ftype == TType.STRING:
                    self.host_id = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TServerStatus')
        if self.read_only is not None:
            oprot.writeFieldBegin('read_only', TType.BOOL, 1)
            oprot.writeBool(self.read_only)
            oprot.writeFieldEnd()
        if self.version is not None:
            oprot.writeFieldBegin('version', TType.STRING, 2)
            oprot.writeString(self.version.encode('utf-8') if sys.version_info[0] == 2 else self.version)
            oprot.writeFieldEnd()
        if self.rendering_enabled is not None:
            oprot.writeFieldBegin('rendering_enabled', TType.BOOL, 3)
            oprot.writeBool(self.rendering_enabled)
            oprot.writeFieldEnd()
        if self.start_time is not None:
            oprot.writeFieldBegin('start_time', TType.I64, 4)
            oprot.writeI64(self.start_time)
            oprot.writeFieldEnd()
        if self.edition is not None:
            oprot.writeFieldBegin('edition', TType.STRING, 5)
            oprot.writeString(self.edition.encode('utf-8') if sys.version_info[0] == 2 else self.edition)
            oprot.writeFieldEnd()
        if self.host_name is not None:
            oprot.writeFieldBegin('host_name', TType.STRING, 6)
            oprot.writeString(self.host_name.encode('utf-8') if sys.version_info[0] == 2 else self.host_name)
            oprot.writeFieldEnd()
        if self.poly_rendering_enabled is not None:
            oprot.writeFieldBegin('poly_rendering_enabled', TType.BOOL, 7)
            oprot.writeBool(self.poly_rendering_enabled)
            oprot.writeFieldEnd()
        if self.role is not None:
            oprot.writeFieldBegin('role', TType.I32, 8)
            oprot.writeI32(self.role)
            oprot.writeFieldEnd()
        if self.renderer_status_json is not None:
            oprot.writeFieldBegin('renderer_status_json', TType.STRING, 9)
            oprot.writeString(self.renderer_status_json.encode('utf-8') if sys.version_info[0] == 2 else self.renderer_status_json)
            oprot.writeFieldEnd()
        if self.host_id is not None:
            oprot.writeFieldBegin('host_id', TType.STRING, 10)
            oprot.writeString(self.host_id.encode('utf-8') if sys.version_info[0] == 2 else self.host_id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TPixel(object):
    """
    Attributes:
     - x
     - y

    """


    def __init__(self, x=None, y=None,):
        self.x = x
        self.y = y

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I64:
                    self.x = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.y = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TPixel')
        if self.x is not None:
            oprot.writeFieldBegin('x', TType.I64, 1)
            oprot.writeI64(self.x)
            oprot.writeFieldEnd()
        if self.y is not None:
            oprot.writeFieldBegin('y', TType.I64, 2)
            oprot.writeI64(self.y)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TPixelTableRowResult(object):
    """
    Attributes:
     - pixel
     - vega_table_name
     - table_id
     - row_id
     - row_set
     - nonce

    """


    def __init__(self, pixel=None, vega_table_name=None, table_id=None, row_id=None, row_set=None, nonce=None,):
        self.pixel = pixel
        self.vega_table_name = vega_table_name
        self.table_id = table_id
        self.row_id = row_id
        self.row_set = row_set
        self.nonce = nonce

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.pixel = TPixel()
                    self.pixel.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.vega_table_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.table_id = []
                    (_etype87, _size84) = iprot.readListBegin()
                    for _i88 in range(_size84):
                        _elem89 = iprot.readI64()
                        self.table_id.append(_elem89)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.row_id = []
                    (_etype93, _size90) = iprot.readListBegin()
                    for _i94 in range(_size90):
                        _elem95 = iprot.readI64()
                        self.row_id.append(_elem95)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRUCT:
                    self.row_set = TRowSet()
                    self.row_set.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.nonce = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TPixelTableRowResult')
        if self.pixel is not None:
            oprot.writeFieldBegin('pixel', TType.STRUCT, 1)
            self.pixel.write(oprot)
            oprot.writeFieldEnd()
        if self.vega_table_name is not None:
            oprot.writeFieldBegin('vega_table_name', TType.STRING, 2)
            oprot.writeString(self.vega_table_name.encode('utf-8') if sys.version_info[0] == 2 else self.vega_table_name)
            oprot.writeFieldEnd()
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.LIST, 3)
            oprot.writeListBegin(TType.I64, len(self.table_id))
            for iter96 in self.table_id:
                oprot.writeI64(iter96)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.row_id is not None:
            oprot.writeFieldBegin('row_id', TType.LIST, 4)
            oprot.writeListBegin(TType.I64, len(self.row_id))
            for iter97 in self.row_id:
                oprot.writeI64(iter97)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.row_set is not None:
            oprot.writeFieldBegin('row_set', TType.STRUCT, 5)
            self.row_set.write(oprot)
            oprot.writeFieldEnd()
        if self.nonce is not None:
            oprot.writeFieldBegin('nonce', TType.STRING, 6)
            oprot.writeString(self.nonce.encode('utf-8') if sys.version_info[0] == 2 else self.nonce)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRenderResult(object):
    """
    Attributes:
     - image
     - nonce
     - execution_time_ms
     - render_time_ms
     - total_time_ms
     - vega_metadata

    """


    def __init__(self, image=None, nonce=None, execution_time_ms=None, render_time_ms=None, total_time_ms=None, vega_metadata=None,):
        self.image = image
        self.nonce = nonce
        self.execution_time_ms = execution_time_ms
        self.render_time_ms = render_time_ms
        self.total_time_ms = total_time_ms
        self.vega_metadata = vega_metadata

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.image = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.nonce = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.execution_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.render_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.total_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.vega_metadata = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRenderResult')
        if self.image is not None:
            oprot.writeFieldBegin('image', TType.STRING, 1)
            oprot.writeBinary(self.image)
            oprot.writeFieldEnd()
        if self.nonce is not None:
            oprot.writeFieldBegin('nonce', TType.STRING, 2)
            oprot.writeString(self.nonce.encode('utf-8') if sys.version_info[0] == 2 else self.nonce)
            oprot.writeFieldEnd()
        if self.execution_time_ms is not None:
            oprot.writeFieldBegin('execution_time_ms', TType.I64, 3)
            oprot.writeI64(self.execution_time_ms)
            oprot.writeFieldEnd()
        if self.render_time_ms is not None:
            oprot.writeFieldBegin('render_time_ms', TType.I64, 4)
            oprot.writeI64(self.render_time_ms)
            oprot.writeFieldEnd()
        if self.total_time_ms is not None:
            oprot.writeFieldBegin('total_time_ms', TType.I64, 5)
            oprot.writeI64(self.total_time_ms)
            oprot.writeFieldEnd()
        if self.vega_metadata is not None:
            oprot.writeFieldBegin('vega_metadata', TType.STRING, 6)
            oprot.writeString(self.vega_metadata.encode('utf-8') if sys.version_info[0] == 2 else self.vega_metadata)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TGpuSpecification(object):
    """
    Attributes:
     - num_sm
     - clock_frequency_kHz
     - memory
     - compute_capability_major
     - compute_capability_minor

    """


    def __init__(self, num_sm=None, clock_frequency_kHz=None, memory=None, compute_capability_major=None, compute_capability_minor=None,):
        self.num_sm = num_sm
        self.clock_frequency_kHz = clock_frequency_kHz
        self.memory = memory
        self.compute_capability_major = compute_capability_major
        self.compute_capability_minor = compute_capability_minor

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.num_sm = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.clock_frequency_kHz = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.memory = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I16:
                    self.compute_capability_major = iprot.readI16()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I16:
                    self.compute_capability_minor = iprot.readI16()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TGpuSpecification')
        if self.num_sm is not None:
            oprot.writeFieldBegin('num_sm', TType.I32, 1)
            oprot.writeI32(self.num_sm)
            oprot.writeFieldEnd()
        if self.clock_frequency_kHz is not None:
            oprot.writeFieldBegin('clock_frequency_kHz', TType.I64, 2)
            oprot.writeI64(self.clock_frequency_kHz)
            oprot.writeFieldEnd()
        if self.memory is not None:
            oprot.writeFieldBegin('memory', TType.I64, 3)
            oprot.writeI64(self.memory)
            oprot.writeFieldEnd()
        if self.compute_capability_major is not None:
            oprot.writeFieldBegin('compute_capability_major', TType.I16, 4)
            oprot.writeI16(self.compute_capability_major)
            oprot.writeFieldEnd()
        if self.compute_capability_minor is not None:
            oprot.writeFieldBegin('compute_capability_minor', TType.I16, 5)
            oprot.writeI16(self.compute_capability_minor)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class THardwareInfo(object):
    """
    Attributes:
     - num_gpu_hw
     - num_cpu_hw
     - num_gpu_allocated
     - start_gpu
     - host_name
     - gpu_info

    """


    def __init__(self, num_gpu_hw=None, num_cpu_hw=None, num_gpu_allocated=None, start_gpu=None, host_name=None, gpu_info=None,):
        self.num_gpu_hw = num_gpu_hw
        self.num_cpu_hw = num_cpu_hw
        self.num_gpu_allocated = num_gpu_allocated
        self.start_gpu = start_gpu
        self.host_name = host_name
        self.gpu_info = gpu_info

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I16:
                    self.num_gpu_hw = iprot.readI16()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I16:
                    self.num_cpu_hw = iprot.readI16()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I16:
                    self.num_gpu_allocated = iprot.readI16()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I16:
                    self.start_gpu = iprot.readI16()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.host_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.LIST:
                    self.gpu_info = []
                    (_etype101, _size98) = iprot.readListBegin()
                    for _i102 in range(_size98):
                        _elem103 = TGpuSpecification()
                        _elem103.read(iprot)
                        self.gpu_info.append(_elem103)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('THardwareInfo')
        if self.num_gpu_hw is not None:
            oprot.writeFieldBegin('num_gpu_hw', TType.I16, 1)
            oprot.writeI16(self.num_gpu_hw)
            oprot.writeFieldEnd()
        if self.num_cpu_hw is not None:
            oprot.writeFieldBegin('num_cpu_hw', TType.I16, 2)
            oprot.writeI16(self.num_cpu_hw)
            oprot.writeFieldEnd()
        if self.num_gpu_allocated is not None:
            oprot.writeFieldBegin('num_gpu_allocated', TType.I16, 3)
            oprot.writeI16(self.num_gpu_allocated)
            oprot.writeFieldEnd()
        if self.start_gpu is not None:
            oprot.writeFieldBegin('start_gpu', TType.I16, 4)
            oprot.writeI16(self.start_gpu)
            oprot.writeFieldEnd()
        if self.host_name is not None:
            oprot.writeFieldBegin('host_name', TType.STRING, 5)
            oprot.writeString(self.host_name.encode('utf-8') if sys.version_info[0] == 2 else self.host_name)
            oprot.writeFieldEnd()
        if self.gpu_info is not None:
            oprot.writeFieldBegin('gpu_info', TType.LIST, 6)
            oprot.writeListBegin(TType.STRUCT, len(self.gpu_info))
            for iter104 in self.gpu_info:
                iter104.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TClusterHardwareInfo(object):
    """
    Attributes:
     - hardware_info

    """


    def __init__(self, hardware_info=None,):
        self.hardware_info = hardware_info

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.hardware_info = []
                    (_etype108, _size105) = iprot.readListBegin()
                    for _i109 in range(_size105):
                        _elem110 = THardwareInfo()
                        _elem110.read(iprot)
                        self.hardware_info.append(_elem110)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TClusterHardwareInfo')
        if self.hardware_info is not None:
            oprot.writeFieldBegin('hardware_info', TType.LIST, 1)
            oprot.writeListBegin(TType.STRUCT, len(self.hardware_info))
            for iter111 in self.hardware_info:
                iter111.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TMemoryData(object):
    """
    Attributes:
     - slab
     - start_page
     - num_pages
     - touch
     - chunk_key
     - buffer_epoch
     - is_free

    """


    def __init__(self, slab=None, start_page=None, num_pages=None, touch=None, chunk_key=None, buffer_epoch=None, is_free=None,):
        self.slab = slab
        self.start_page = start_page
        self.num_pages = num_pages
        self.touch = touch
        self.chunk_key = chunk_key
        self.buffer_epoch = buffer_epoch
        self.is_free = is_free

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I64:
                    self.slab = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.start_page = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.num_pages = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.touch = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.LIST:
                    self.chunk_key = []
                    (_etype115, _size112) = iprot.readListBegin()
                    for _i116 in range(_size112):
                        _elem117 = iprot.readI64()
                        self.chunk_key.append(_elem117)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I32:
                    self.buffer_epoch = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.BOOL:
                    self.is_free = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TMemoryData')
        if self.slab is not None:
            oprot.writeFieldBegin('slab', TType.I64, 1)
            oprot.writeI64(self.slab)
            oprot.writeFieldEnd()
        if self.start_page is not None:
            oprot.writeFieldBegin('start_page', TType.I32, 2)
            oprot.writeI32(self.start_page)
            oprot.writeFieldEnd()
        if self.num_pages is not None:
            oprot.writeFieldBegin('num_pages', TType.I64, 3)
            oprot.writeI64(self.num_pages)
            oprot.writeFieldEnd()
        if self.touch is not None:
            oprot.writeFieldBegin('touch', TType.I32, 4)
            oprot.writeI32(self.touch)
            oprot.writeFieldEnd()
        if self.chunk_key is not None:
            oprot.writeFieldBegin('chunk_key', TType.LIST, 5)
            oprot.writeListBegin(TType.I64, len(self.chunk_key))
            for iter118 in self.chunk_key:
                oprot.writeI64(iter118)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.buffer_epoch is not None:
            oprot.writeFieldBegin('buffer_epoch', TType.I32, 6)
            oprot.writeI32(self.buffer_epoch)
            oprot.writeFieldEnd()
        if self.is_free is not None:
            oprot.writeFieldBegin('is_free', TType.BOOL, 7)
            oprot.writeBool(self.is_free)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TNodeMemoryInfo(object):
    """
    Attributes:
     - host_name
     - page_size
     - max_num_pages
     - num_pages_allocated
     - is_allocation_capped
     - node_memory_data

    """


    def __init__(self, host_name=None, page_size=None, max_num_pages=None, num_pages_allocated=None, is_allocation_capped=None, node_memory_data=None,):
        self.host_name = host_name
        self.page_size = page_size
        self.max_num_pages = max_num_pages
        self.num_pages_allocated = num_pages_allocated
        self.is_allocation_capped = is_allocation_capped
        self.node_memory_data = node_memory_data

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.host_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.page_size = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.max_num_pages = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.num_pages_allocated = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.is_allocation_capped = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.LIST:
                    self.node_memory_data = []
                    (_etype122, _size119) = iprot.readListBegin()
                    for _i123 in range(_size119):
                        _elem124 = TMemoryData()
                        _elem124.read(iprot)
                        self.node_memory_data.append(_elem124)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TNodeMemoryInfo')
        if self.host_name is not None:
            oprot.writeFieldBegin('host_name', TType.STRING, 1)
            oprot.writeString(self.host_name.encode('utf-8') if sys.version_info[0] == 2 else self.host_name)
            oprot.writeFieldEnd()
        if self.page_size is not None:
            oprot.writeFieldBegin('page_size', TType.I64, 2)
            oprot.writeI64(self.page_size)
            oprot.writeFieldEnd()
        if self.max_num_pages is not None:
            oprot.writeFieldBegin('max_num_pages', TType.I64, 3)
            oprot.writeI64(self.max_num_pages)
            oprot.writeFieldEnd()
        if self.num_pages_allocated is not None:
            oprot.writeFieldBegin('num_pages_allocated', TType.I64, 4)
            oprot.writeI64(self.num_pages_allocated)
            oprot.writeFieldEnd()
        if self.is_allocation_capped is not None:
            oprot.writeFieldBegin('is_allocation_capped', TType.BOOL, 5)
            oprot.writeBool(self.is_allocation_capped)
            oprot.writeFieldEnd()
        if self.node_memory_data is not None:
            oprot.writeFieldBegin('node_memory_data', TType.LIST, 6)
            oprot.writeListBegin(TType.STRUCT, len(self.node_memory_data))
            for iter125 in self.node_memory_data:
                iter125.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTableMeta(object):
    """
    Attributes:
     - table_name
     - num_cols
     - is_view
     - is_replicated
     - shard_count
     - max_rows
     - table_id
     - max_table_id
     - col_types
     - col_names

    """


    def __init__(self, table_name=None, num_cols=None, is_view=None, is_replicated=None, shard_count=None, max_rows=None, table_id=None, max_table_id=None, col_types=None, col_names=None,):
        self.table_name = table_name
        self.num_cols = num_cols
        self.is_view = is_view
        self.is_replicated = is_replicated
        self.shard_count = shard_count
        self.max_rows = max_rows
        self.table_id = table_id
        self.max_table_id = max_table_id
        self.col_types = col_types
        self.col_names = col_names

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.table_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.num_cols = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.is_view = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.is_replicated = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I64:
                    self.shard_count = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.I64:
                    self.max_rows = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.I64:
                    self.table_id = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.I64:
                    self.max_table_id = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 10:
                if ftype == TType.LIST:
                    self.col_types = []
                    (_etype129, _size126) = iprot.readListBegin()
                    for _i130 in range(_size126):
                        _elem131 = heavydb.common.ttypes.TTypeInfo()
                        _elem131.read(iprot)
                        self.col_types.append(_elem131)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 11:
                if ftype == TType.LIST:
                    self.col_names = []
                    (_etype135, _size132) = iprot.readListBegin()
                    for _i136 in range(_size132):
                        _elem137 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                        self.col_names.append(_elem137)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTableMeta')
        if self.table_name is not None:
            oprot.writeFieldBegin('table_name', TType.STRING, 1)
            oprot.writeString(self.table_name.encode('utf-8') if sys.version_info[0] == 2 else self.table_name)
            oprot.writeFieldEnd()
        if self.num_cols is not None:
            oprot.writeFieldBegin('num_cols', TType.I64, 2)
            oprot.writeI64(self.num_cols)
            oprot.writeFieldEnd()
        if self.is_view is not None:
            oprot.writeFieldBegin('is_view', TType.BOOL, 4)
            oprot.writeBool(self.is_view)
            oprot.writeFieldEnd()
        if self.is_replicated is not None:
            oprot.writeFieldBegin('is_replicated', TType.BOOL, 5)
            oprot.writeBool(self.is_replicated)
            oprot.writeFieldEnd()
        if self.shard_count is not None:
            oprot.writeFieldBegin('shard_count', TType.I64, 6)
            oprot.writeI64(self.shard_count)
            oprot.writeFieldEnd()
        if self.max_rows is not None:
            oprot.writeFieldBegin('max_rows', TType.I64, 7)
            oprot.writeI64(self.max_rows)
            oprot.writeFieldEnd()
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I64, 8)
            oprot.writeI64(self.table_id)
            oprot.writeFieldEnd()
        if self.max_table_id is not None:
            oprot.writeFieldBegin('max_table_id', TType.I64, 9)
            oprot.writeI64(self.max_table_id)
            oprot.writeFieldEnd()
        if self.col_types is not None:
            oprot.writeFieldBegin('col_types', TType.LIST, 10)
            oprot.writeListBegin(TType.STRUCT, len(self.col_types))
            for iter138 in self.col_types:
                iter138.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.col_names is not None:
            oprot.writeFieldBegin('col_names', TType.LIST, 11)
            oprot.writeListBegin(TType.STRING, len(self.col_names))
            for iter139 in self.col_names:
                oprot.writeString(iter139.encode('utf-8') if sys.version_info[0] == 2 else iter139)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTableRefreshInfo(object):
    """
    Attributes:
     - update_type
     - timing_type
     - start_date_time
     - interval_type
     - interval_count
     - last_refresh_time
     - next_refresh_time

    """


    def __init__(self, update_type=None, timing_type=None, start_date_time=None, interval_type=None, interval_count=None, last_refresh_time=None, next_refresh_time=None,):
        self.update_type = update_type
        self.timing_type = timing_type
        self.start_date_time = start_date_time
        self.interval_type = interval_type
        self.interval_count = interval_count
        self.last_refresh_time = last_refresh_time
        self.next_refresh_time = next_refresh_time

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.update_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.timing_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.start_date_time = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.interval_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.interval_count = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.last_refresh_time = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.next_refresh_time = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTableRefreshInfo')
        if self.update_type is not None:
            oprot.writeFieldBegin('update_type', TType.I32, 1)
            oprot.writeI32(self.update_type)
            oprot.writeFieldEnd()
        if self.timing_type is not None:
            oprot.writeFieldBegin('timing_type', TType.I32, 2)
            oprot.writeI32(self.timing_type)
            oprot.writeFieldEnd()
        if self.start_date_time is not None:
            oprot.writeFieldBegin('start_date_time', TType.STRING, 3)
            oprot.writeString(self.start_date_time.encode('utf-8') if sys.version_info[0] == 2 else self.start_date_time)
            oprot.writeFieldEnd()
        if self.interval_type is not None:
            oprot.writeFieldBegin('interval_type', TType.I32, 4)
            oprot.writeI32(self.interval_type)
            oprot.writeFieldEnd()
        if self.interval_count is not None:
            oprot.writeFieldBegin('interval_count', TType.I64, 5)
            oprot.writeI64(self.interval_count)
            oprot.writeFieldEnd()
        if self.last_refresh_time is not None:
            oprot.writeFieldBegin('last_refresh_time', TType.STRING, 6)
            oprot.writeString(self.last_refresh_time.encode('utf-8') if sys.version_info[0] == 2 else self.last_refresh_time)
            oprot.writeFieldEnd()
        if self.next_refresh_time is not None:
            oprot.writeFieldBegin('next_refresh_time', TType.STRING, 7)
            oprot.writeString(self.next_refresh_time.encode('utf-8') if sys.version_info[0] == 2 else self.next_refresh_time)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTableDetails(object):
    """
    Attributes:
     - row_desc
     - fragment_size
     - page_size
     - max_rows
     - view_sql
     - shard_count
     - key_metainfo
     - is_temporary
     - partition_detail
     - table_type
     - refresh_info
     - sharded_column_name

    """


    def __init__(self, row_desc=None, fragment_size=None, page_size=None, max_rows=None, view_sql=None, shard_count=None, key_metainfo=None, is_temporary=None, partition_detail=None, table_type=None, refresh_info=None, sharded_column_name=None,):
        self.row_desc = row_desc
        self.fragment_size = fragment_size
        self.page_size = page_size
        self.max_rows = max_rows
        self.view_sql = view_sql
        self.shard_count = shard_count
        self.key_metainfo = key_metainfo
        self.is_temporary = is_temporary
        self.partition_detail = partition_detail
        self.table_type = table_type
        self.refresh_info = refresh_info
        self.sharded_column_name = sharded_column_name

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.row_desc = []
                    (_etype143, _size140) = iprot.readListBegin()
                    for _i144 in range(_size140):
                        _elem145 = TColumnType()
                        _elem145.read(iprot)
                        self.row_desc.append(_elem145)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.fragment_size = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.page_size = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.max_rows = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.view_sql = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I64:
                    self.shard_count = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.key_metainfo = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.BOOL:
                    self.is_temporary = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.I32:
                    self.partition_detail = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 10:
                if ftype == TType.I32:
                    self.table_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 11:
                if ftype == TType.STRUCT:
                    self.refresh_info = TTableRefreshInfo()
                    self.refresh_info.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 12:
                if ftype == TType.STRING:
                    self.sharded_column_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTableDetails')
        if self.row_desc is not None:
            oprot.writeFieldBegin('row_desc', TType.LIST, 1)
            oprot.writeListBegin(TType.STRUCT, len(self.row_desc))
            for iter146 in self.row_desc:
                iter146.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.fragment_size is not None:
            oprot.writeFieldBegin('fragment_size', TType.I64, 2)
            oprot.writeI64(self.fragment_size)
            oprot.writeFieldEnd()
        if self.page_size is not None:
            oprot.writeFieldBegin('page_size', TType.I64, 3)
            oprot.writeI64(self.page_size)
            oprot.writeFieldEnd()
        if self.max_rows is not None:
            oprot.writeFieldBegin('max_rows', TType.I64, 4)
            oprot.writeI64(self.max_rows)
            oprot.writeFieldEnd()
        if self.view_sql is not None:
            oprot.writeFieldBegin('view_sql', TType.STRING, 5)
            oprot.writeString(self.view_sql.encode('utf-8') if sys.version_info[0] == 2 else self.view_sql)
            oprot.writeFieldEnd()
        if self.shard_count is not None:
            oprot.writeFieldBegin('shard_count', TType.I64, 6)
            oprot.writeI64(self.shard_count)
            oprot.writeFieldEnd()
        if self.key_metainfo is not None:
            oprot.writeFieldBegin('key_metainfo', TType.STRING, 7)
            oprot.writeString(self.key_metainfo.encode('utf-8') if sys.version_info[0] == 2 else self.key_metainfo)
            oprot.writeFieldEnd()
        if self.is_temporary is not None:
            oprot.writeFieldBegin('is_temporary', TType.BOOL, 8)
            oprot.writeBool(self.is_temporary)
            oprot.writeFieldEnd()
        if self.partition_detail is not None:
            oprot.writeFieldBegin('partition_detail', TType.I32, 9)
            oprot.writeI32(self.partition_detail)
            oprot.writeFieldEnd()
        if self.table_type is not None:
            oprot.writeFieldBegin('table_type', TType.I32, 10)
            oprot.writeI32(self.table_type)
            oprot.writeFieldEnd()
        if self.refresh_info is not None:
            oprot.writeFieldBegin('refresh_info', TType.STRUCT, 11)
            self.refresh_info.write(oprot)
            oprot.writeFieldEnd()
        if self.sharded_column_name is not None:
            oprot.writeFieldBegin('sharded_column_name', TType.STRING, 12)
            oprot.writeString(self.sharded_column_name.encode('utf-8') if sys.version_info[0] == 2 else self.sharded_column_name)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TColumnRange(object):
    """
    Attributes:
     - type
     - col_id
     - table_id
     - has_nulls
     - int_min
     - int_max
     - bucket
     - fp_min
     - fp_max
     - db_id

    """


    def __init__(self, type=None, col_id=None, table_id=None, has_nulls=None, int_min=None, int_max=None, bucket=None, fp_min=None, fp_max=None, db_id=None,):
        self.type = type
        self.col_id = col_id
        self.table_id = table_id
        self.has_nulls = has_nulls
        self.int_min = int_min
        self.int_max = int_max
        self.bucket = bucket
        self.fp_min = fp_min
        self.fp_max = fp_max
        self.db_id = db_id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.col_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.table_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.has_nulls = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.int_min = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I64:
                    self.int_max = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.I64:
                    self.bucket = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.DOUBLE:
                    self.fp_min = iprot.readDouble()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.DOUBLE:
                    self.fp_max = iprot.readDouble()
                else:
                    iprot.skip(ftype)
            elif fid == 10:
                if ftype == TType.I32:
                    self.db_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TColumnRange')
        if self.type is not None:
            oprot.writeFieldBegin('type', TType.I32, 1)
            oprot.writeI32(self.type)
            oprot.writeFieldEnd()
        if self.col_id is not None:
            oprot.writeFieldBegin('col_id', TType.I32, 2)
            oprot.writeI32(self.col_id)
            oprot.writeFieldEnd()
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I32, 3)
            oprot.writeI32(self.table_id)
            oprot.writeFieldEnd()
        if self.has_nulls is not None:
            oprot.writeFieldBegin('has_nulls', TType.BOOL, 4)
            oprot.writeBool(self.has_nulls)
            oprot.writeFieldEnd()
        if self.int_min is not None:
            oprot.writeFieldBegin('int_min', TType.I64, 5)
            oprot.writeI64(self.int_min)
            oprot.writeFieldEnd()
        if self.int_max is not None:
            oprot.writeFieldBegin('int_max', TType.I64, 6)
            oprot.writeI64(self.int_max)
            oprot.writeFieldEnd()
        if self.bucket is not None:
            oprot.writeFieldBegin('bucket', TType.I64, 7)
            oprot.writeI64(self.bucket)
            oprot.writeFieldEnd()
        if self.fp_min is not None:
            oprot.writeFieldBegin('fp_min', TType.DOUBLE, 8)
            oprot.writeDouble(self.fp_min)
            oprot.writeFieldEnd()
        if self.fp_max is not None:
            oprot.writeFieldBegin('fp_max', TType.DOUBLE, 9)
            oprot.writeDouble(self.fp_max)
            oprot.writeFieldEnd()
        if self.db_id is not None:
            oprot.writeFieldBegin('db_id', TType.I32, 10)
            oprot.writeI32(self.db_id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDictionaryGeneration(object):
    """
    Attributes:
     - dict_id
     - entry_count
     - db_id

    """


    def __init__(self, dict_id=None, entry_count=None, db_id=None,):
        self.dict_id = dict_id
        self.entry_count = entry_count
        self.db_id = db_id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.dict_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.entry_count = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.db_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDictionaryGeneration')
        if self.dict_id is not None:
            oprot.writeFieldBegin('dict_id', TType.I32, 1)
            oprot.writeI32(self.dict_id)
            oprot.writeFieldEnd()
        if self.entry_count is not None:
            oprot.writeFieldBegin('entry_count', TType.I64, 2)
            oprot.writeI64(self.entry_count)
            oprot.writeFieldEnd()
        if self.db_id is not None:
            oprot.writeFieldBegin('db_id', TType.I32, 3)
            oprot.writeI32(self.db_id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTableGeneration(object):
    """
    Attributes:
     - table_id
     - tuple_count
     - start_rowid
     - db_id

    """


    def __init__(self, table_id=None, tuple_count=None, start_rowid=None, db_id=None,):
        self.table_id = table_id
        self.tuple_count = tuple_count
        self.start_rowid = start_rowid
        self.db_id = db_id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.table_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I64:
                    self.tuple_count = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.start_rowid = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.db_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTableGeneration')
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I32, 1)
            oprot.writeI32(self.table_id)
            oprot.writeFieldEnd()
        if self.tuple_count is not None:
            oprot.writeFieldBegin('tuple_count', TType.I64, 2)
            oprot.writeI64(self.tuple_count)
            oprot.writeFieldEnd()
        if self.start_rowid is not None:
            oprot.writeFieldBegin('start_rowid', TType.I64, 3)
            oprot.writeI64(self.start_rowid)
            oprot.writeFieldEnd()
        if self.db_id is not None:
            oprot.writeFieldBegin('db_id', TType.I32, 4)
            oprot.writeI32(self.db_id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTableCacheStatus(object):
    """
    Attributes:
     - table_id
     - db_id
     - is_cached_on_disk

    """


    def __init__(self, table_id=None, db_id=None, is_cached_on_disk=None,):
        self.table_id = table_id
        self.db_id = db_id
        self.is_cached_on_disk = is_cached_on_disk

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.table_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.db_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.is_cached_on_disk = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTableCacheStatus')
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I32, 1)
            oprot.writeI32(self.table_id)
            oprot.writeFieldEnd()
        if self.db_id is not None:
            oprot.writeFieldBegin('db_id', TType.I32, 2)
            oprot.writeI32(self.db_id)
            oprot.writeFieldEnd()
        if self.is_cached_on_disk is not None:
            oprot.writeFieldBegin('is_cached_on_disk', TType.BOOL, 3)
            oprot.writeBool(self.is_cached_on_disk)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TPendingQuery(object):
    """
    Attributes:
     - id
     - column_ranges
     - dictionary_generations
     - table_generations
     - parent_session_id
     - table_cache_status

    """


    def __init__(self, id=None, column_ranges=None, dictionary_generations=None, table_generations=None, parent_session_id=None, table_cache_status=None,):
        self.id = id
        self.column_ranges = column_ranges
        self.dictionary_generations = dictionary_generations
        self.table_generations = table_generations
        self.parent_session_id = parent_session_id
        self.table_cache_status = table_cache_status

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I64:
                    self.id = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.column_ranges = []
                    (_etype150, _size147) = iprot.readListBegin()
                    for _i151 in range(_size147):
                        _elem152 = TColumnRange()
                        _elem152.read(iprot)
                        self.column_ranges.append(_elem152)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.dictionary_generations = []
                    (_etype156, _size153) = iprot.readListBegin()
                    for _i157 in range(_size153):
                        _elem158 = TDictionaryGeneration()
                        _elem158.read(iprot)
                        self.dictionary_generations.append(_elem158)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.table_generations = []
                    (_etype162, _size159) = iprot.readListBegin()
                    for _i163 in range(_size159):
                        _elem164 = TTableGeneration()
                        _elem164.read(iprot)
                        self.table_generations.append(_elem164)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.parent_session_id = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.LIST:
                    self.table_cache_status = []
                    (_etype168, _size165) = iprot.readListBegin()
                    for _i169 in range(_size165):
                        _elem170 = TTableCacheStatus()
                        _elem170.read(iprot)
                        self.table_cache_status.append(_elem170)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TPendingQuery')
        if self.id is not None:
            oprot.writeFieldBegin('id', TType.I64, 1)
            oprot.writeI64(self.id)
            oprot.writeFieldEnd()
        if self.column_ranges is not None:
            oprot.writeFieldBegin('column_ranges', TType.LIST, 2)
            oprot.writeListBegin(TType.STRUCT, len(self.column_ranges))
            for iter171 in self.column_ranges:
                iter171.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.dictionary_generations is not None:
            oprot.writeFieldBegin('dictionary_generations', TType.LIST, 3)
            oprot.writeListBegin(TType.STRUCT, len(self.dictionary_generations))
            for iter172 in self.dictionary_generations:
                iter172.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.table_generations is not None:
            oprot.writeFieldBegin('table_generations', TType.LIST, 4)
            oprot.writeListBegin(TType.STRUCT, len(self.table_generations))
            for iter173 in self.table_generations:
                iter173.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.parent_session_id is not None:
            oprot.writeFieldBegin('parent_session_id', TType.STRING, 5)
            oprot.writeString(self.parent_session_id.encode('utf-8') if sys.version_info[0] == 2 else self.parent_session_id)
            oprot.writeFieldEnd()
        if self.table_cache_status is not None:
            oprot.writeFieldBegin('table_cache_status', TType.LIST, 6)
            oprot.writeListBegin(TType.STRUCT, len(self.table_cache_status))
            for iter174 in self.table_cache_status:
                iter174.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TVarLen(object):
    """
    Attributes:
     - payload
     - is_null

    """


    def __init__(self, payload=None, is_null=None,):
        self.payload = payload
        self.is_null = is_null

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.payload = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.is_null = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TVarLen')
        if self.payload is not None:
            oprot.writeFieldBegin('payload', TType.STRING, 1)
            oprot.writeBinary(self.payload)
            oprot.writeFieldEnd()
        if self.is_null is not None:
            oprot.writeFieldBegin('is_null', TType.BOOL, 2)
            oprot.writeBool(self.is_null)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDataBlockPtr(object):
    """
    Attributes:
     - fixed_len_data
     - var_len_data

    """


    def __init__(self, fixed_len_data=None, var_len_data=None,):
        self.fixed_len_data = fixed_len_data
        self.var_len_data = var_len_data

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.fixed_len_data = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.var_len_data = []
                    (_etype178, _size175) = iprot.readListBegin()
                    for _i179 in range(_size175):
                        _elem180 = TVarLen()
                        _elem180.read(iprot)
                        self.var_len_data.append(_elem180)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDataBlockPtr')
        if self.fixed_len_data is not None:
            oprot.writeFieldBegin('fixed_len_data', TType.STRING, 1)
            oprot.writeBinary(self.fixed_len_data)
            oprot.writeFieldEnd()
        if self.var_len_data is not None:
            oprot.writeFieldBegin('var_len_data', TType.LIST, 2)
            oprot.writeListBegin(TType.STRUCT, len(self.var_len_data))
            for iter181 in self.var_len_data:
                iter181.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TInsertData(object):
    """
    Attributes:
     - db_id
     - table_id
     - column_ids
     - data
     - num_rows
     - is_default

    """


    def __init__(self, db_id=None, table_id=None, column_ids=None, data=None, num_rows=None, is_default=None,):
        self.db_id = db_id
        self.table_id = table_id
        self.column_ids = column_ids
        self.data = data
        self.num_rows = num_rows
        self.is_default = is_default

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.db_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.table_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.column_ids = []
                    (_etype185, _size182) = iprot.readListBegin()
                    for _i186 in range(_size182):
                        _elem187 = iprot.readI32()
                        self.column_ids.append(_elem187)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.data = []
                    (_etype191, _size188) = iprot.readListBegin()
                    for _i192 in range(_size188):
                        _elem193 = TDataBlockPtr()
                        _elem193.read(iprot)
                        self.data.append(_elem193)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.num_rows = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.LIST:
                    self.is_default = []
                    (_etype197, _size194) = iprot.readListBegin()
                    for _i198 in range(_size194):
                        _elem199 = iprot.readBool()
                        self.is_default.append(_elem199)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TInsertData')
        if self.db_id is not None:
            oprot.writeFieldBegin('db_id', TType.I32, 1)
            oprot.writeI32(self.db_id)
            oprot.writeFieldEnd()
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I32, 2)
            oprot.writeI32(self.table_id)
            oprot.writeFieldEnd()
        if self.column_ids is not None:
            oprot.writeFieldBegin('column_ids', TType.LIST, 3)
            oprot.writeListBegin(TType.I32, len(self.column_ids))
            for iter200 in self.column_ids:
                oprot.writeI32(iter200)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.data is not None:
            oprot.writeFieldBegin('data', TType.LIST, 4)
            oprot.writeListBegin(TType.STRUCT, len(self.data))
            for iter201 in self.data:
                iter201.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.num_rows is not None:
            oprot.writeFieldBegin('num_rows', TType.I64, 5)
            oprot.writeI64(self.num_rows)
            oprot.writeFieldEnd()
        if self.is_default is not None:
            oprot.writeFieldBegin('is_default', TType.LIST, 6)
            oprot.writeListBegin(TType.BOOL, len(self.is_default))
            for iter202 in self.is_default:
                oprot.writeBool(iter202)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TChunkData(object):
    """
    Attributes:
     - data_buffer
     - index_buffer

    """


    def __init__(self, data_buffer=None, index_buffer=None,):
        self.data_buffer = data_buffer
        self.index_buffer = index_buffer

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.data_buffer = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.index_buffer = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TChunkData')
        if self.data_buffer is not None:
            oprot.writeFieldBegin('data_buffer', TType.STRING, 1)
            oprot.writeBinary(self.data_buffer)
            oprot.writeFieldEnd()
        if self.index_buffer is not None:
            oprot.writeFieldBegin('index_buffer', TType.STRING, 2)
            oprot.writeBinary(self.index_buffer)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TInsertChunks(object):
    """
    Attributes:
     - db_id
     - table_id
     - data
     - valid_indices
     - num_rows

    """


    def __init__(self, db_id=None, table_id=None, data=None, valid_indices=None, num_rows=None,):
        self.db_id = db_id
        self.table_id = table_id
        self.data = data
        self.valid_indices = valid_indices
        self.num_rows = num_rows

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.db_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.table_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.data = []
                    (_etype206, _size203) = iprot.readListBegin()
                    for _i207 in range(_size203):
                        _elem208 = TChunkData()
                        _elem208.read(iprot)
                        self.data.append(_elem208)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.valid_indices = []
                    (_etype212, _size209) = iprot.readListBegin()
                    for _i213 in range(_size209):
                        _elem214 = iprot.readI64()
                        self.valid_indices.append(_elem214)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.num_rows = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TInsertChunks')
        if self.db_id is not None:
            oprot.writeFieldBegin('db_id', TType.I32, 1)
            oprot.writeI32(self.db_id)
            oprot.writeFieldEnd()
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I32, 2)
            oprot.writeI32(self.table_id)
            oprot.writeFieldEnd()
        if self.data is not None:
            oprot.writeFieldBegin('data', TType.LIST, 3)
            oprot.writeListBegin(TType.STRUCT, len(self.data))
            for iter215 in self.data:
                iter215.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.valid_indices is not None:
            oprot.writeFieldBegin('valid_indices', TType.LIST, 4)
            oprot.writeListBegin(TType.I64, len(self.valid_indices))
            for iter216 in self.valid_indices:
                oprot.writeI64(iter216)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.num_rows is not None:
            oprot.writeFieldBegin('num_rows', TType.I64, 5)
            oprot.writeI64(self.num_rows)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TPendingRenderQuery(object):
    """
    Attributes:
     - id

    """


    def __init__(self, id=None,):
        self.id = id

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I64:
                    self.id = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TPendingRenderQuery')
        if self.id is not None:
            oprot.writeFieldBegin('id', TType.I64, 1)
            oprot.writeI64(self.id)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRenderParseResult(object):
    """
    Attributes:
     - merge_type
     - node_id
     - execution_time_ms
     - render_time_ms
     - total_time_ms

    """


    def __init__(self, merge_type=None, node_id=None, execution_time_ms=None, render_time_ms=None, total_time_ms=None,):
        self.merge_type = merge_type
        self.node_id = node_id
        self.execution_time_ms = execution_time_ms
        self.render_time_ms = render_time_ms
        self.total_time_ms = total_time_ms

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.merge_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.node_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.execution_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.render_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.total_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRenderParseResult')
        if self.merge_type is not None:
            oprot.writeFieldBegin('merge_type', TType.I32, 1)
            oprot.writeI32(self.merge_type)
            oprot.writeFieldEnd()
        if self.node_id is not None:
            oprot.writeFieldBegin('node_id', TType.I32, 2)
            oprot.writeI32(self.node_id)
            oprot.writeFieldEnd()
        if self.execution_time_ms is not None:
            oprot.writeFieldBegin('execution_time_ms', TType.I64, 3)
            oprot.writeI64(self.execution_time_ms)
            oprot.writeFieldEnd()
        if self.render_time_ms is not None:
            oprot.writeFieldBegin('render_time_ms', TType.I64, 4)
            oprot.writeI64(self.render_time_ms)
            oprot.writeFieldEnd()
        if self.total_time_ms is not None:
            oprot.writeFieldBegin('total_time_ms', TType.I64, 5)
            oprot.writeI64(self.total_time_ms)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRawRenderPassDataResult(object):
    """
    Attributes:
     - num_pixel_channels
     - num_pixel_samples
     - pixels
     - row_ids_A
     - row_ids_B
     - table_ids
     - accum_data
     - accum_depth

    """


    def __init__(self, num_pixel_channels=None, num_pixel_samples=None, pixels=None, row_ids_A=None, row_ids_B=None, table_ids=None, accum_data=None, accum_depth=None,):
        self.num_pixel_channels = num_pixel_channels
        self.num_pixel_samples = num_pixel_samples
        self.pixels = pixels
        self.row_ids_A = row_ids_A
        self.row_ids_B = row_ids_B
        self.table_ids = table_ids
        self.accum_data = accum_data
        self.accum_depth = accum_depth

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.num_pixel_channels = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.num_pixel_samples = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.pixels = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.row_ids_A = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.row_ids_B = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.table_ids = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.accum_data = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.I32:
                    self.accum_depth = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRawRenderPassDataResult')
        if self.num_pixel_channels is not None:
            oprot.writeFieldBegin('num_pixel_channels', TType.I32, 1)
            oprot.writeI32(self.num_pixel_channels)
            oprot.writeFieldEnd()
        if self.num_pixel_samples is not None:
            oprot.writeFieldBegin('num_pixel_samples', TType.I32, 2)
            oprot.writeI32(self.num_pixel_samples)
            oprot.writeFieldEnd()
        if self.pixels is not None:
            oprot.writeFieldBegin('pixels', TType.STRING, 3)
            oprot.writeBinary(self.pixels)
            oprot.writeFieldEnd()
        if self.row_ids_A is not None:
            oprot.writeFieldBegin('row_ids_A', TType.STRING, 4)
            oprot.writeBinary(self.row_ids_A)
            oprot.writeFieldEnd()
        if self.row_ids_B is not None:
            oprot.writeFieldBegin('row_ids_B', TType.STRING, 5)
            oprot.writeBinary(self.row_ids_B)
            oprot.writeFieldEnd()
        if self.table_ids is not None:
            oprot.writeFieldBegin('table_ids', TType.STRING, 6)
            oprot.writeBinary(self.table_ids)
            oprot.writeFieldEnd()
        if self.accum_data is not None:
            oprot.writeFieldBegin('accum_data', TType.STRING, 7)
            oprot.writeBinary(self.accum_data)
            oprot.writeFieldEnd()
        if self.accum_depth is not None:
            oprot.writeFieldBegin('accum_depth', TType.I32, 8)
            oprot.writeI32(self.accum_depth)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRawPixelData(object):
    """
    Attributes:
     - width
     - height
     - render_pass_map

    """


    def __init__(self, width=None, height=None, render_pass_map=None,):
        self.width = width
        self.height = height
        self.render_pass_map = render_pass_map

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.width = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.height = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.MAP:
                    self.render_pass_map = {}
                    (_ktype218, _vtype219, _size217) = iprot.readMapBegin()
                    for _i221 in range(_size217):
                        _key222 = iprot.readI32()
                        _val223 = TRawRenderPassDataResult()
                        _val223.read(iprot)
                        self.render_pass_map[_key222] = _val223
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRawPixelData')
        if self.width is not None:
            oprot.writeFieldBegin('width', TType.I32, 1)
            oprot.writeI32(self.width)
            oprot.writeFieldEnd()
        if self.height is not None:
            oprot.writeFieldBegin('height', TType.I32, 2)
            oprot.writeI32(self.height)
            oprot.writeFieldEnd()
        if self.render_pass_map is not None:
            oprot.writeFieldBegin('render_pass_map', TType.MAP, 3)
            oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.render_pass_map))
            for kiter224, viter225 in self.render_pass_map.items():
                oprot.writeI32(kiter224)
                viter225.write(oprot)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRenderDatum(object):
    """
    Attributes:
     - type
     - cnt
     - value

    """


    def __init__(self, type=None, cnt=None, value=None,):
        self.type = type
        self.cnt = cnt
        self.value = value

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.cnt = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.value = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRenderDatum')
        if self.type is not None:
            oprot.writeFieldBegin('type', TType.I32, 1)
            oprot.writeI32(self.type)
            oprot.writeFieldEnd()
        if self.cnt is not None:
            oprot.writeFieldBegin('cnt', TType.I32, 2)
            oprot.writeI32(self.cnt)
            oprot.writeFieldEnd()
        if self.value is not None:
            oprot.writeFieldBegin('value', TType.STRING, 3)
            oprot.writeBinary(self.value)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TRenderStepResult(object):
    """
    Attributes:
     - merge_data
     - raw_pixel_data
     - execution_time_ms
     - render_time_ms
     - total_time_ms

    """


    def __init__(self, merge_data=None, raw_pixel_data=None, execution_time_ms=None, render_time_ms=None, total_time_ms=None,):
        self.merge_data = merge_data
        self.raw_pixel_data = raw_pixel_data
        self.execution_time_ms = execution_time_ms
        self.render_time_ms = render_time_ms
        self.total_time_ms = total_time_ms

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.MAP:
                    self.merge_data = {}
                    (_ktype227, _vtype228, _size226) = iprot.readMapBegin()
                    for _i230 in range(_size226):
                        _key231 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                        _val232 = {}
                        (_ktype234, _vtype235, _size233) = iprot.readMapBegin()
                        for _i237 in range(_size233):
                            _key238 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                            _val239 = {}
                            (_ktype241, _vtype242, _size240) = iprot.readMapBegin()
                            for _i244 in range(_size240):
                                _key245 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                                _val246 = {}
                                (_ktype248, _vtype249, _size247) = iprot.readMapBegin()
                                for _i251 in range(_size247):
                                    _key252 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                                    _val253 = []
                                    (_etype257, _size254) = iprot.readListBegin()
                                    for _i258 in range(_size254):
                                        _elem259 = TRenderDatum()
                                        _elem259.read(iprot)
                                        _val253.append(_elem259)
                                    iprot.readListEnd()
                                    _val246[_key252] = _val253
                                iprot.readMapEnd()
                                _val239[_key245] = _val246
                            iprot.readMapEnd()
                            _val232[_key238] = _val239
                        iprot.readMapEnd()
                        self.merge_data[_key231] = _val232
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.raw_pixel_data = TRawPixelData()
                    self.raw_pixel_data.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.execution_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.render_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.total_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRenderStepResult')
        if self.merge_data is not None:
            oprot.writeFieldBegin('merge_data', TType.MAP, 1)
            oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.merge_data))
            for kiter260, viter261 in self.merge_data.items():
                oprot.writeString(kiter260.encode('utf-8') if sys.version_info[0] == 2 else kiter260)
                oprot.writeMapBegin(TType.STRING, TType.MAP, len(viter261))
                for kiter262, viter263 in viter261.items():
                    oprot.writeString(kiter262.encode('utf-8') if sys.version_info[0] == 2 else kiter262)
                    oprot.writeMapBegin(TType.STRING, TType.MAP, len(viter263))
                    for kiter264, viter265 in viter263.items():
                        oprot.writeString(kiter264.encode('utf-8') if sys.version_info[0] == 2 else kiter264)
                        oprot.writeMapBegin(TType.STRING, TType.LIST, len(viter265))
                        for kiter266, viter267 in viter265.items():
                            oprot.writeString(kiter266.encode('utf-8') if sys.version_info[0] == 2 else kiter266)
                            oprot.writeListBegin(TType.STRUCT, len(viter267))
                            for iter268 in viter267:
                                iter268.write(oprot)
                            oprot.writeListEnd()
                        oprot.writeMapEnd()
                    oprot.writeMapEnd()
                oprot.writeMapEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.raw_pixel_data is not None:
            oprot.writeFieldBegin('raw_pixel_data', TType.STRUCT, 2)
            self.raw_pixel_data.write(oprot)
            oprot.writeFieldEnd()
        if self.execution_time_ms is not None:
            oprot.writeFieldBegin('execution_time_ms', TType.I64, 3)
            oprot.writeI64(self.execution_time_ms)
            oprot.writeFieldEnd()
        if self.render_time_ms is not None:
            oprot.writeFieldBegin('render_time_ms', TType.I64, 4)
            oprot.writeI64(self.render_time_ms)
            oprot.writeFieldEnd()
        if self.total_time_ms is not None:
            oprot.writeFieldBegin('total_time_ms', TType.I64, 5)
            oprot.writeI64(self.total_time_ms)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDatabasePermissions(object):
    """
    Attributes:
     - create_
     - delete_
     - view_sql_editor_
     - access_

    """


    def __init__(self, create_=None, delete_=None, view_sql_editor_=None, access_=None,):
        self.create_ = create_
        self.delete_ = delete_
        self.view_sql_editor_ = view_sql_editor_
        self.access_ = access_

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.create_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.delete_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.view_sql_editor_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.access_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDatabasePermissions')
        if self.create_ is not None:
            oprot.writeFieldBegin('create_', TType.BOOL, 1)
            oprot.writeBool(self.create_)
            oprot.writeFieldEnd()
        if self.delete_ is not None:
            oprot.writeFieldBegin('delete_', TType.BOOL, 2)
            oprot.writeBool(self.delete_)
            oprot.writeFieldEnd()
        if self.view_sql_editor_ is not None:
            oprot.writeFieldBegin('view_sql_editor_', TType.BOOL, 3)
            oprot.writeBool(self.view_sql_editor_)
            oprot.writeFieldEnd()
        if self.access_ is not None:
            oprot.writeFieldBegin('access_', TType.BOOL, 4)
            oprot.writeBool(self.access_)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTablePermissions(object):
    """
    Attributes:
     - create_
     - drop_
     - select_
     - insert_
     - update_
     - delete_
     - truncate_
     - alter_

    """


    def __init__(self, create_=None, drop_=None, select_=None, insert_=None, update_=None, delete_=None, truncate_=None, alter_=None,):
        self.create_ = create_
        self.drop_ = drop_
        self.select_ = select_
        self.insert_ = insert_
        self.update_ = update_
        self.delete_ = delete_
        self.truncate_ = truncate_
        self.alter_ = alter_

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.create_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.drop_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.select_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.insert_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.update_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.BOOL:
                    self.delete_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.BOOL:
                    self.truncate_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.BOOL:
                    self.alter_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTablePermissions')
        if self.create_ is not None:
            oprot.writeFieldBegin('create_', TType.BOOL, 1)
            oprot.writeBool(self.create_)
            oprot.writeFieldEnd()
        if self.drop_ is not None:
            oprot.writeFieldBegin('drop_', TType.BOOL, 2)
            oprot.writeBool(self.drop_)
            oprot.writeFieldEnd()
        if self.select_ is not None:
            oprot.writeFieldBegin('select_', TType.BOOL, 3)
            oprot.writeBool(self.select_)
            oprot.writeFieldEnd()
        if self.insert_ is not None:
            oprot.writeFieldBegin('insert_', TType.BOOL, 4)
            oprot.writeBool(self.insert_)
            oprot.writeFieldEnd()
        if self.update_ is not None:
            oprot.writeFieldBegin('update_', TType.BOOL, 5)
            oprot.writeBool(self.update_)
            oprot.writeFieldEnd()
        if self.delete_ is not None:
            oprot.writeFieldBegin('delete_', TType.BOOL, 6)
            oprot.writeBool(self.delete_)
            oprot.writeFieldEnd()
        if self.truncate_ is not None:
            oprot.writeFieldBegin('truncate_', TType.BOOL, 7)
            oprot.writeBool(self.truncate_)
            oprot.writeFieldEnd()
        if self.alter_ is not None:
            oprot.writeFieldBegin('alter_', TType.BOOL, 8)
            oprot.writeBool(self.alter_)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDashboardPermissions(object):
    """
    Attributes:
     - create_
     - delete_
     - view_
     - edit_

    """


    def __init__(self, create_=None, delete_=None, view_=None, edit_=None,):
        self.create_ = create_
        self.delete_ = delete_
        self.view_ = view_
        self.edit_ = edit_

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.create_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.delete_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.view_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.edit_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDashboardPermissions')
        if self.create_ is not None:
            oprot.writeFieldBegin('create_', TType.BOOL, 1)
            oprot.writeBool(self.create_)
            oprot.writeFieldEnd()
        if self.delete_ is not None:
            oprot.writeFieldBegin('delete_', TType.BOOL, 2)
            oprot.writeBool(self.delete_)
            oprot.writeFieldEnd()
        if self.view_ is not None:
            oprot.writeFieldBegin('view_', TType.BOOL, 3)
            oprot.writeBool(self.view_)
            oprot.writeFieldEnd()
        if self.edit_ is not None:
            oprot.writeFieldBegin('edit_', TType.BOOL, 4)
            oprot.writeBool(self.edit_)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TViewPermissions(object):
    """
    Attributes:
     - create_
     - drop_
     - select_
     - insert_
     - update_
     - delete_

    """


    def __init__(self, create_=None, drop_=None, select_=None, insert_=None, update_=None, delete_=None,):
        self.create_ = create_
        self.drop_ = drop_
        self.select_ = select_
        self.insert_ = insert_
        self.update_ = update_
        self.delete_ = delete_

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.create_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.drop_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.select_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.insert_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.BOOL:
                    self.update_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.BOOL:
                    self.delete_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TViewPermissions')
        if self.create_ is not None:
            oprot.writeFieldBegin('create_', TType.BOOL, 1)
            oprot.writeBool(self.create_)
            oprot.writeFieldEnd()
        if self.drop_ is not None:
            oprot.writeFieldBegin('drop_', TType.BOOL, 2)
            oprot.writeBool(self.drop_)
            oprot.writeFieldEnd()
        if self.select_ is not None:
            oprot.writeFieldBegin('select_', TType.BOOL, 3)
            oprot.writeBool(self.select_)
            oprot.writeFieldEnd()
        if self.insert_ is not None:
            oprot.writeFieldBegin('insert_', TType.BOOL, 4)
            oprot.writeBool(self.insert_)
            oprot.writeFieldEnd()
        if self.update_ is not None:
            oprot.writeFieldBegin('update_', TType.BOOL, 5)
            oprot.writeBool(self.update_)
            oprot.writeFieldEnd()
        if self.delete_ is not None:
            oprot.writeFieldBegin('delete_', TType.BOOL, 6)
            oprot.writeBool(self.delete_)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TServerPermissions(object):
    """
    Attributes:
     - create_
     - drop_
     - alter_
     - usage_

    """


    def __init__(self, create_=None, drop_=None, alter_=None, usage_=None,):
        self.create_ = create_
        self.drop_ = drop_
        self.alter_ = alter_
        self.usage_ = usage_

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.BOOL:
                    self.create_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.drop_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.BOOL:
                    self.alter_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.usage_ = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TServerPermissions')
        if self.create_ is not None:
            oprot.writeFieldBegin('create_', TType.BOOL, 1)
            oprot.writeBool(self.create_)
            oprot.writeFieldEnd()
        if self.drop_ is not None:
            oprot.writeFieldBegin('drop_', TType.BOOL, 2)
            oprot.writeBool(self.drop_)
            oprot.writeFieldEnd()
        if self.alter_ is not None:
            oprot.writeFieldBegin('alter_', TType.BOOL, 3)
            oprot.writeBool(self.alter_)
            oprot.writeFieldEnd()
        if self.usage_ is not None:
            oprot.writeFieldBegin('usage_', TType.BOOL, 4)
            oprot.writeBool(self.usage_)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDBObjectPermissions(object):
    """
    Attributes:
     - database_permissions_
     - table_permissions_
     - dashboard_permissions_
     - view_permissions_
     - server_permissions_

    """


    def __init__(self, database_permissions_=None, table_permissions_=None, dashboard_permissions_=None, view_permissions_=None, server_permissions_=None,):
        self.database_permissions_ = database_permissions_
        self.table_permissions_ = table_permissions_
        self.dashboard_permissions_ = dashboard_permissions_
        self.view_permissions_ = view_permissions_
        self.server_permissions_ = server_permissions_

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRUCT:
                    self.database_permissions_ = TDatabasePermissions()
                    self.database_permissions_.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.table_permissions_ = TTablePermissions()
                    self.table_permissions_.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.dashboard_permissions_ = TDashboardPermissions()
                    self.dashboard_permissions_.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.view_permissions_ = TViewPermissions()
                    self.view_permissions_.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRUCT:
                    self.server_permissions_ = TServerPermissions()
                    self.server_permissions_.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDBObjectPermissions')
        if self.database_permissions_ is not None:
            oprot.writeFieldBegin('database_permissions_', TType.STRUCT, 1)
            self.database_permissions_.write(oprot)
            oprot.writeFieldEnd()
        if self.table_permissions_ is not None:
            oprot.writeFieldBegin('table_permissions_', TType.STRUCT, 2)
            self.table_permissions_.write(oprot)
            oprot.writeFieldEnd()
        if self.dashboard_permissions_ is not None:
            oprot.writeFieldBegin('dashboard_permissions_', TType.STRUCT, 3)
            self.dashboard_permissions_.write(oprot)
            oprot.writeFieldEnd()
        if self.view_permissions_ is not None:
            oprot.writeFieldBegin('view_permissions_', TType.STRUCT, 4)
            self.view_permissions_.write(oprot)
            oprot.writeFieldEnd()
        if self.server_permissions_ is not None:
            oprot.writeFieldBegin('server_permissions_', TType.STRUCT, 5)
            self.server_permissions_.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDBObject(object):
    """
    Attributes:
     - objectName
     - objectType
     - privs
     - grantee
     - privilegeObjectType
     - objectId

    """


    def __init__(self, objectName=None, objectType=None, privs=None, grantee=None, privilegeObjectType=None, objectId=None,):
        self.objectName = objectName
        self.objectType = objectType
        self.privs = privs
        self.grantee = grantee
        self.privilegeObjectType = privilegeObjectType
        self.objectId = objectId

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.objectName = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.objectType = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.privs = []
                    (_etype272, _size269) = iprot.readListBegin()
                    for _i273 in range(_size269):
                        _elem274 = iprot.readBool()
                        self.privs.append(_elem274)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.grantee = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I32:
                    self.privilegeObjectType = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I32:
                    self.objectId = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDBObject')
        if self.objectName is not None:
            oprot.writeFieldBegin('objectName', TType.STRING, 1)
            oprot.writeString(self.objectName.encode('utf-8') if sys.version_info[0] == 2 else self.objectName)
            oprot.writeFieldEnd()
        if self.objectType is not None:
            oprot.writeFieldBegin('objectType', TType.I32, 2)
            oprot.writeI32(self.objectType)
            oprot.writeFieldEnd()
        if self.privs is not None:
            oprot.writeFieldBegin('privs', TType.LIST, 3)
            oprot.writeListBegin(TType.BOOL, len(self.privs))
            for iter275 in self.privs:
                oprot.writeBool(iter275)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.grantee is not None:
            oprot.writeFieldBegin('grantee', TType.STRING, 4)
            oprot.writeString(self.grantee.encode('utf-8') if sys.version_info[0] == 2 else self.grantee)
            oprot.writeFieldEnd()
        if self.privilegeObjectType is not None:
            oprot.writeFieldBegin('privilegeObjectType', TType.I32, 5)
            oprot.writeI32(self.privilegeObjectType)
            oprot.writeFieldEnd()
        if self.objectId is not None:
            oprot.writeFieldBegin('objectId', TType.I32, 6)
            oprot.writeI32(self.objectId)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDashboardGrantees(object):
    """
    Attributes:
     - name
     - is_user
     - permissions

    """


    def __init__(self, name=None, is_user=None, permissions=None,):
        self.name = name
        self.is_user = is_user
        self.permissions = permissions

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.BOOL:
                    self.is_user = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.permissions = TDashboardPermissions()
                    self.permissions.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDashboardGrantees')
        if self.name is not None:
            oprot.writeFieldBegin('name', TType.STRING, 1)
            oprot.writeString(self.name.encode('utf-8') if sys.version_info[0] == 2 else self.name)
            oprot.writeFieldEnd()
        if self.is_user is not None:
            oprot.writeFieldBegin('is_user', TType.BOOL, 2)
            oprot.writeBool(self.is_user)
            oprot.writeFieldEnd()
        if self.permissions is not None:
            oprot.writeFieldBegin('permissions', TType.STRUCT, 3)
            self.permissions.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TDashboard(object):
    """
    Attributes:
     - dashboard_name
     - dashboard_state
     - image_hash
     - update_time
     - dashboard_metadata
     - dashboard_id
     - dashboard_owner
     - is_dash_shared
     - dashboard_permissions

    """


    def __init__(self, dashboard_name=None, dashboard_state=None, image_hash=None, update_time=None, dashboard_metadata=None, dashboard_id=None, dashboard_owner=None, is_dash_shared=None, dashboard_permissions=None,):
        self.dashboard_name = dashboard_name
        self.dashboard_state = dashboard_state
        self.image_hash = image_hash
        self.update_time = update_time
        self.dashboard_metadata = dashboard_metadata
        self.dashboard_id = dashboard_id
        self.dashboard_owner = dashboard_owner
        self.is_dash_shared = is_dash_shared
        self.dashboard_permissions = dashboard_permissions

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.dashboard_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.dashboard_state = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.image_hash = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.update_time = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.dashboard_metadata = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I32:
                    self.dashboard_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.dashboard_owner = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.BOOL:
                    self.is_dash_shared = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.STRUCT:
                    self.dashboard_permissions = TDashboardPermissions()
                    self.dashboard_permissions.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TDashboard')
        if self.dashboard_name is not None:
            oprot.writeFieldBegin('dashboard_name', TType.STRING, 1)
            oprot.writeString(self.dashboard_name.encode('utf-8') if sys.version_info[0] == 2 else self.dashboard_name)
            oprot.writeFieldEnd()
        if self.dashboard_state is not None:
            oprot.writeFieldBegin('dashboard_state', TType.STRING, 2)
            oprot.writeString(self.dashboard_state.encode('utf-8') if sys.version_info[0] == 2 else self.dashboard_state)
            oprot.writeFieldEnd()
        if self.image_hash is not None:
            oprot.writeFieldBegin('image_hash', TType.STRING, 3)
            oprot.writeString(self.image_hash.encode('utf-8') if sys.version_info[0] == 2 else self.image_hash)
            oprot.writeFieldEnd()
        if self.update_time is not None:
            oprot.writeFieldBegin('update_time', TType.STRING, 4)
            oprot.writeString(self.update_time.encode('utf-8') if sys.version_info[0] == 2 else self.update_time)
            oprot.writeFieldEnd()
        if self.dashboard_metadata is not None:
            oprot.writeFieldBegin('dashboard_metadata', TType.STRING, 5)
            oprot.writeString(self.dashboard_metadata.encode('utf-8') if sys.version_info[0] == 2 else self.dashboard_metadata)
            oprot.writeFieldEnd()
        if self.dashboard_id is not None:
            oprot.writeFieldBegin('dashboard_id', TType.I32, 6)
            oprot.writeI32(self.dashboard_id)
            oprot.writeFieldEnd()
        if self.dashboard_owner is not None:
            oprot.writeFieldBegin('dashboard_owner', TType.STRING, 7)
            oprot.writeString(self.dashboard_owner.encode('utf-8') if sys.version_info[0] == 2 else self.dashboard_owner)
            oprot.writeFieldEnd()
        if self.is_dash_shared is not None:
            oprot.writeFieldBegin('is_dash_shared', TType.BOOL, 8)
            oprot.writeBool(self.is_dash_shared)
            oprot.writeFieldEnd()
        if self.dashboard_permissions is not None:
            oprot.writeFieldBegin('dashboard_permissions', TType.STRUCT, 9)
            self.dashboard_permissions.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TLicenseInfo(object):
    """
    Attributes:
     - claims

    """


    def __init__(self, claims=None,):
        self.claims = claims

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.LIST:
                    self.claims = []
                    (_etype279, _size276) = iprot.readListBegin()
                    for _i280 in range(_size276):
                        _elem281 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                        self.claims.append(_elem281)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TLicenseInfo')
        if self.claims is not None:
            oprot.writeFieldBegin('claims', TType.LIST, 1)
            oprot.writeListBegin(TType.STRING, len(self.claims))
            for iter282 in self.claims:
                oprot.writeString(iter282.encode('utf-8') if sys.version_info[0] == 2 else iter282)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TSessionInfo(object):
    """
    Attributes:
     - user
     - database
     - start_time
     - is_super

    """


    def __init__(self, user=None, database=None, start_time=None, is_super=None,):
        self.user = user
        self.database = database
        self.start_time = start_time
        self.is_super = is_super

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.user = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.database = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.start_time = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.BOOL:
                    self.is_super = iprot.readBool()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TSessionInfo')
        if self.user is not None:
            oprot.writeFieldBegin('user', TType.STRING, 1)
            oprot.writeString(self.user.encode('utf-8') if sys.version_info[0] == 2 else self.user)
            oprot.writeFieldEnd()
        if self.database is not None:
            oprot.writeFieldBegin('database', TType.STRING, 2)
            oprot.writeString(self.database.encode('utf-8') if sys.version_info[0] == 2 else self.database)
            oprot.writeFieldEnd()
        if self.start_time is not None:
            oprot.writeFieldBegin('start_time', TType.I64, 3)
            oprot.writeI64(self.start_time)
            oprot.writeFieldEnd()
        if self.is_super is not None:
            oprot.writeFieldBegin('is_super', TType.BOOL, 4)
            oprot.writeBool(self.is_super)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TGeoFileLayerInfo(object):
    """
    Attributes:
     - name
     - contents

    """


    def __init__(self, name=None, contents=None,):
        self.name = name
        self.contents = contents

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.contents = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TGeoFileLayerInfo')
        if self.name is not None:
            oprot.writeFieldBegin('name', TType.STRING, 1)
            oprot.writeString(self.name.encode('utf-8') if sys.version_info[0] == 2 else self.name)
            oprot.writeFieldEnd()
        if self.contents is not None:
            oprot.writeFieldBegin('contents', TType.I32, 2)
            oprot.writeI32(self.contents)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TTableEpochInfo(object):
    """
    Attributes:
     - table_id
     - table_epoch
     - leaf_index

    """


    def __init__(self, table_id=None, table_epoch=None, leaf_index=None,):
        self.table_id = table_id
        self.table_epoch = table_epoch
        self.leaf_index = leaf_index

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.table_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.table_epoch = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.leaf_index = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TTableEpochInfo')
        if self.table_id is not None:
            oprot.writeFieldBegin('table_id', TType.I32, 1)
            oprot.writeI32(self.table_id)
            oprot.writeFieldEnd()
        if self.table_epoch is not None:
            oprot.writeFieldBegin('table_epoch', TType.I32, 2)
            oprot.writeI32(self.table_epoch)
            oprot.writeFieldEnd()
        if self.leaf_index is not None:
            oprot.writeFieldBegin('leaf_index', TType.I32, 3)
            oprot.writeI32(self.leaf_index)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TCustomExpression(object):
    """
    Attributes:
     - id
     - name
     - expression_json
     - data_source_type
     - data_source_id
     - is_deleted
     - data_source_name

    """


    def __init__(self, id=None, name=None, expression_json=None, data_source_type=None, data_source_id=None, is_deleted=None, data_source_name=None,):
        self.id = id
        self.name = name
        self.expression_json = expression_json
        self.data_source_type = data_source_type
        self.data_source_id = data_source_id
        self.is_deleted = is_deleted
        self.data_source_name = data_source_name

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRING:
                    self.expression_json = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I32:
                    self.data_source_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I32:
                    self.data_source_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.BOOL:
                    self.is_deleted = iprot.readBool()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.STRING:
                    self.data_source_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TCustomExpression')
        if self.id is not None:
            oprot.writeFieldBegin('id', TType.I32, 1)
            oprot.writeI32(self.id)
            oprot.writeFieldEnd()
        if self.name is not None:
            oprot.writeFieldBegin('name', TType.STRING, 2)
            oprot.writeString(self.name.encode('utf-8') if sys.version_info[0] == 2 else self.name)
            oprot.writeFieldEnd()
        if self.expression_json is not None:
            oprot.writeFieldBegin('expression_json', TType.STRING, 4)
            oprot.writeString(self.expression_json.encode('utf-8') if sys.version_info[0] == 2 else self.expression_json)
            oprot.writeFieldEnd()
        if self.data_source_type is not None:
            oprot.writeFieldBegin('data_source_type', TType.I32, 5)
            oprot.writeI32(self.data_source_type)
            oprot.writeFieldEnd()
        if self.data_source_id is not None:
            oprot.writeFieldBegin('data_source_id', TType.I32, 6)
            oprot.writeI32(self.data_source_id)
            oprot.writeFieldEnd()
        if self.is_deleted is not None:
            oprot.writeFieldBegin('is_deleted', TType.BOOL, 7)
            oprot.writeBool(self.is_deleted)
            oprot.writeFieldEnd()
        if self.data_source_name is not None:
            oprot.writeFieldBegin('data_source_name', TType.STRING, 8)
            oprot.writeString(self.data_source_name.encode('utf-8') if sys.version_info[0] == 2 else self.data_source_name)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TQueryInfo(object):
    """
    Attributes:
     - query_session_id
     - query_public_session_id
     - current_status
     - executor_id
     - submitted
     - query_str
     - login_name
     - client_address
     - db_name
     - exec_device_type

    """


    def __init__(self, query_session_id=None, query_public_session_id=None, current_status=None, executor_id=None, submitted=None, query_str=None, login_name=None, client_address=None, db_name=None, exec_device_type=None,):
        self.query_session_id = query_session_id
        self.query_public_session_id = query_public_session_id
        self.current_status = current_status
        self.executor_id = executor_id
        self.submitted = submitted
        self.query_str = query_str
        self.login_name = login_name
        self.client_address = client_address
        self.db_name = db_name
        self.exec_device_type = exec_device_type

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.STRING:
                    self.query_session_id = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.query_public_session_id = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.current_status = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.executor_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.STRING:
                    self.submitted = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.STRING:
                    self.query_str = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 7:
                if ftype == TType.STRING:
                    self.login_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 8:
                if ftype == TType.STRING:
                    self.client_address = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 9:
                if ftype == TType.STRING:
                    self.db_name = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 10:
                if ftype == TType.STRING:
                    self.exec_device_type = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TQueryInfo')
        if self.query_session_id is not None:
            oprot.writeFieldBegin('query_session_id', TType.STRING, 1)
            oprot.writeString(self.query_session_id.encode('utf-8') if sys.version_info[0] == 2 else self.query_session_id)
            oprot.writeFieldEnd()
        if self.query_public_session_id is not None:
            oprot.writeFieldBegin('query_public_session_id', TType.STRING, 2)
            oprot.writeString(self.query_public_session_id.encode('utf-8') if sys.version_info[0] == 2 else self.query_public_session_id)
            oprot.writeFieldEnd()
        if self.current_status is not None:
            oprot.writeFieldBegin('current_status', TType.STRING, 3)
            oprot.writeString(self.current_status.encode('utf-8') if sys.version_info[0] == 2 else self.current_status)
            oprot.writeFieldEnd()
        if self.executor_id is not None:
            oprot.writeFieldBegin('executor_id', TType.I32, 4)
            oprot.writeI32(self.executor_id)
            oprot.writeFieldEnd()
        if self.submitted is not None:
            oprot.writeFieldBegin('submitted', TType.STRING, 5)
            oprot.writeString(self.submitted.encode('utf-8') if sys.version_info[0] == 2 else self.submitted)
            oprot.writeFieldEnd()
        if self.query_str is not None:
            oprot.writeFieldBegin('query_str', TType.STRING, 6)
            oprot.writeString(self.query_str.encode('utf-8') if sys.version_info[0] == 2 else self.query_str)
            oprot.writeFieldEnd()
        if self.login_name is not None:
            oprot.writeFieldBegin('login_name', TType.STRING, 7)
            oprot.writeString(self.login_name.encode('utf-8') if sys.version_info[0] == 2 else self.login_name)
            oprot.writeFieldEnd()
        if self.client_address is not None:
            oprot.writeFieldBegin('client_address', TType.STRING, 8)
            oprot.writeString(self.client_address.encode('utf-8') if sys.version_info[0] == 2 else self.client_address)
            oprot.writeFieldEnd()
        if self.db_name is not None:
            oprot.writeFieldBegin('db_name', TType.STRING, 9)
            oprot.writeString(self.db_name.encode('utf-8') if sys.version_info[0] == 2 else self.db_name)
            oprot.writeFieldEnd()
        if self.exec_device_type is not None:
            oprot.writeFieldBegin('exec_device_type', TType.STRING, 10)
            oprot.writeString(self.exec_device_type.encode('utf-8') if sys.version_info[0] == 2 else self.exec_device_type)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)


class TLeafInfo(object):
    """
    Attributes:
     - leaf_id
     - num_leaves

    """


    def __init__(self, leaf_id=None, num_leaves=None,):
        self.leaf_id = leaf_id
        self.num_leaves = num_leaves

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.I32:
                    self.leaf_id = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.num_leaves = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TLeafInfo')
        if self.leaf_id is not None:
            oprot.writeFieldBegin('leaf_id', TType.I32, 1)
            oprot.writeI32(self.leaf_id)
            oprot.writeFieldEnd()
        if self.num_leaves is not None:
            oprot.writeFieldBegin('num_leaves', TType.I32, 2)
            oprot.writeI32(self.num_leaves)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not (self == other)
all_structs.append(TDatumVal)
TDatumVal.thrift_spec = (
    None,  # 0
    (1, TType.I64, 'int_val', None, None, ),  # 1
    (2, TType.DOUBLE, 'real_val', None, None, ),  # 2
    (3, TType.STRING, 'str_val', 'UTF8', None, ),  # 3
    (4, TType.LIST, 'arr_val', (TType.STRUCT, [TDatum, None], False), None, ),  # 4
)
all_structs.append(TDatum)
TDatum.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'val', [TDatumVal, None], None, ),  # 1
    (2, TType.BOOL, 'is_null', None, None, ),  # 2
)
all_structs.append(TStringValue)
TStringValue.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'str_val', 'UTF8', None, ),  # 1
    (2, TType.BOOL, 'is_null', None, None, ),  # 2
)
all_structs.append(TColumnType)
TColumnType.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'col_name', 'UTF8', None, ),  # 1
    (2, TType.STRUCT, 'col_type', [heavydb.common.ttypes.TTypeInfo, None], None, ),  # 2
    (3, TType.BOOL, 'is_reserved_keyword', None, None, ),  # 3
    (4, TType.STRING, 'src_name', 'UTF8', None, ),  # 4
    (5, TType.BOOL, 'is_system', None, None, ),  # 5
    (6, TType.BOOL, 'is_physical', None, None, ),  # 6
    (7, TType.I64, 'col_id', None, None, ),  # 7
    (8, TType.STRING, 'default_value', 'UTF8', None, ),  # 8
)
all_structs.append(TRow)
TRow.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'cols', (TType.STRUCT, [TDatum, None], False), None, ),  # 1
)
all_structs.append(TColumnData)
TColumnData.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'int_col', (TType.I64, None, False), None, ),  # 1
    (2, TType.LIST, 'real_col', (TType.DOUBLE, None, False), None, ),  # 2
    (3, TType.LIST, 'str_col', (TType.STRING, 'UTF8', False), None, ),  # 3
    (4, TType.LIST, 'arr_col', (TType.STRUCT, [TColumn, None], False), None, ),  # 4
)
all_structs.append(TColumn)
TColumn.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'data', [TColumnData, None], None, ),  # 1
    (2, TType.LIST, 'nulls', (TType.BOOL, None, False), None, ),  # 2
)
all_structs.append(TStringRow)
TStringRow.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'cols', (TType.STRUCT, [TStringValue, None], False), None, ),  # 1
)
all_structs.append(TKrb5Session)
TKrb5Session.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'sessionId', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'krbToken', 'UTF8', None, ),  # 2
)
all_structs.append(TStepResult)
TStepResult.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'serialized_rows', [heavydb.serialized_result_set.ttypes.TSerializedRows, None], None, ),  # 1
    (2, TType.BOOL, 'execution_finished', None, None, ),  # 2
    (3, TType.I32, 'merge_type', None, None, ),  # 3
    (4, TType.BOOL, 'sharded', None, None, ),  # 4
    (5, TType.LIST, 'row_desc', (TType.STRUCT, [TColumnType, None], False), None, ),  # 5
    (6, TType.I32, 'node_id', None, None, ),  # 6
)
all_structs.append(TRowSet)
TRowSet.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'row_desc', (TType.STRUCT, [TColumnType, None], False), None, ),  # 1
    (2, TType.LIST, 'rows', (TType.STRUCT, [TRow, None], False), None, ),  # 2
    (3, TType.LIST, 'columns', (TType.STRUCT, [TColumn, None], False), None, ),  # 3
    (4, TType.BOOL, 'is_columnar', None, None, ),  # 4
)
all_structs.append(TQueryResult)
TQueryResult.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'row_set', [TRowSet, None], None, ),  # 1
    (2, TType.I64, 'execution_time_ms', None, None, ),  # 2
    (3, TType.I64, 'total_time_ms', None, None, ),  # 3
    (4, TType.STRING, 'nonce', 'UTF8', None, ),  # 4
    (5, TType.STRING, 'debug', 'UTF8', None, ),  # 5
    (6, TType.BOOL, 'success', None, True, ),  # 6
    (7, TType.I32, 'query_type', None, 0, ),  # 7
)
all_structs.append(TDataFrame)
TDataFrame.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'sm_handle', 'BINARY', None, ),  # 1
    (2, TType.I64, 'sm_size', None, None, ),  # 2
    (3, TType.STRING, 'df_handle', 'BINARY', None, ),  # 3
    (4, TType.I64, 'df_size', None, None, ),  # 4
    (5, TType.I64, 'execution_time_ms', None, None, ),  # 5
    (6, TType.I64, 'arrow_conversion_time_ms', None, None, ),  # 6
    (7, TType.STRING, 'df_buffer', 'BINARY', None, ),  # 7
)
all_structs.append(TDBInfo)
TDBInfo.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'db_name', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'db_owner', 'UTF8', None, ),  # 2
)
all_structs.append(TDBException)
TDBException.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'error_msg', 'UTF8', None, ),  # 1
)
all_structs.append(TCopyParams)
TCopyParams.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'delimiter', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'null_str', 'UTF8', None, ),  # 2
    (3, TType.I32, 'has_header', None, 0, ),  # 3
    (4, TType.BOOL, 'quoted', None, None, ),  # 4
    (5, TType.STRING, 'quote', 'UTF8', None, ),  # 5
    (6, TType.STRING, 'escape', 'UTF8', None, ),  # 6
    (7, TType.STRING, 'line_delim', 'UTF8', None, ),  # 7
    (8, TType.STRING, 'array_delim', 'UTF8', None, ),  # 8
    (9, TType.STRING, 'array_begin', 'UTF8', None, ),  # 9
    (10, TType.STRING, 'array_end', 'UTF8', None, ),  # 10
    (11, TType.I32, 'threads', None, None, ),  # 11
    (12, TType.I32, 'source_type', None, 0, ),  # 12
    (13, TType.STRING, 's3_access_key', 'UTF8', None, ),  # 13
    (14, TType.STRING, 's3_secret_key', 'UTF8', None, ),  # 14
    (15, TType.STRING, 's3_region', 'UTF8', None, ),  # 15
    (16, TType.I32, 'geo_coords_encoding', None, 6, ),  # 16
    (17, TType.I32, 'geo_coords_comp_param', None, 32, ),  # 17
    (18, TType.I32, 'geo_coords_type', None, 18, ),  # 18
    (19, TType.I32, 'geo_coords_srid', None, 4326, ),  # 19
    (20, TType.BOOL, 'sanitize_column_names', None, True, ),  # 20
    (21, TType.STRING, 'geo_layer_name', 'UTF8', None, ),  # 21
    (22, TType.STRING, 's3_endpoint', 'UTF8', None, ),  # 22
    (23, TType.BOOL, 'geo_assign_render_groups', None, False, ),  # 23
    (24, TType.BOOL, 'geo_explode_collections', None, False, ),  # 24
    (25, TType.I32, 'source_srid', None, 0, ),  # 25
    (26, TType.STRING, 's3_session_token', 'UTF8', None, ),  # 26
    (27, TType.I32, 'raster_point_type', None, 1, ),  # 27
    (28, TType.STRING, 'raster_import_bands', 'UTF8', None, ),  # 28
    (29, TType.I32, 'raster_scanlines_per_thread', None, None, ),  # 29
    (30, TType.I32, 'raster_point_transform', None, 1, ),  # 30
    (31, TType.BOOL, 'raster_point_compute_angle', None, False, ),  # 31
    (32, TType.STRING, 'raster_import_dimensions', 'UTF8', None, ),  # 32
    (33, TType.STRING, 'odbc_dsn', 'UTF8', None, ),  # 33
    (34, TType.STRING, 'odbc_connection_string', 'UTF8', None, ),  # 34
    (35, TType.STRING, 'odbc_sql_select', 'UTF8', None, ),  # 35
    (36, TType.STRING, 'odbc_sql_order_by', 'UTF8', None, ),  # 36
    (37, TType.STRING, 'odbc_username', 'UTF8', None, ),  # 37
    (38, TType.STRING, 'odbc_password', 'UTF8', None, ),  # 38
    (39, TType.STRING, 'odbc_credential_string', 'UTF8', None, ),  # 39
    (40, TType.STRING, 'add_metadata_columns', 'UTF8', None, ),  # 40
    (41, TType.BOOL, 'trim_spaces', None, True, ),  # 41
    (42, TType.BOOL, 'geo_validate_geometry', None, False, ),  # 42
)
all_structs.append(TCreateParams)
TCreateParams.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'is_replicated', None, None, ),  # 1
)
all_structs.append(TDetectResult)
TDetectResult.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'row_set', [TRowSet, None], None, ),  # 1
    (2, TType.STRUCT, 'copy_params', [TCopyParams, None], None, ),  # 2
)
all_structs.append(TImportStatus)
TImportStatus.thrift_spec = (
    None,  # 0
    (1, TType.I64, 'elapsed', None, None, ),  # 1
    (2, TType.I64, 'rows_completed', None, None, ),  # 2
    (3, TType.I64, 'rows_estimated', None, None, ),  # 3
    (4, TType.I64, 'rows_rejected', None, None, ),  # 4
)
all_structs.append(TFrontendView)
TFrontendView.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'view_name', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'view_state', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'image_hash', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'update_time', 'UTF8', None, ),  # 4
    (5, TType.STRING, 'view_metadata', 'UTF8', None, ),  # 5
)
all_structs.append(TServerStatus)
TServerStatus.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'read_only', None, None, ),  # 1
    (2, TType.STRING, 'version', 'UTF8', None, ),  # 2
    (3, TType.BOOL, 'rendering_enabled', None, None, ),  # 3
    (4, TType.I64, 'start_time', None, None, ),  # 4
    (5, TType.STRING, 'edition', 'UTF8', None, ),  # 5
    (6, TType.STRING, 'host_name', 'UTF8', None, ),  # 6
    (7, TType.BOOL, 'poly_rendering_enabled', None, None, ),  # 7
    (8, TType.I32, 'role', None, None, ),  # 8
    (9, TType.STRING, 'renderer_status_json', 'UTF8', None, ),  # 9
    (10, TType.STRING, 'host_id', 'UTF8', None, ),  # 10
)
all_structs.append(TPixel)
TPixel.thrift_spec = (
    None,  # 0
    (1, TType.I64, 'x', None, None, ),  # 1
    (2, TType.I64, 'y', None, None, ),  # 2
)
all_structs.append(TPixelTableRowResult)
TPixelTableRowResult.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'pixel', [TPixel, None], None, ),  # 1
    (2, TType.STRING, 'vega_table_name', 'UTF8', None, ),  # 2
    (3, TType.LIST, 'table_id', (TType.I64, None, False), None, ),  # 3
    (4, TType.LIST, 'row_id', (TType.I64, None, False), None, ),  # 4
    (5, TType.STRUCT, 'row_set', [TRowSet, None], None, ),  # 5
    (6, TType.STRING, 'nonce', 'UTF8', None, ),  # 6
)
all_structs.append(TRenderResult)
TRenderResult.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'image', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'nonce', 'UTF8', None, ),  # 2
    (3, TType.I64, 'execution_time_ms', None, None, ),  # 3
    (4, TType.I64, 'render_time_ms', None, None, ),  # 4
    (5, TType.I64, 'total_time_ms', None, None, ),  # 5
    (6, TType.STRING, 'vega_metadata', 'UTF8', None, ),  # 6
)
all_structs.append(TGpuSpecification)
TGpuSpecification.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'num_sm', None, None, ),  # 1
    (2, TType.I64, 'clock_frequency_kHz', None, None, ),  # 2
    (3, TType.I64, 'memory', None, None, ),  # 3
    (4, TType.I16, 'compute_capability_major', None, None, ),  # 4
    (5, TType.I16, 'compute_capability_minor', None, None, ),  # 5
)
all_structs.append(THardwareInfo)
THardwareInfo.thrift_spec = (
    None,  # 0
    (1, TType.I16, 'num_gpu_hw', None, None, ),  # 1
    (2, TType.I16, 'num_cpu_hw', None, None, ),  # 2
    (3, TType.I16, 'num_gpu_allocated', None, None, ),  # 3
    (4, TType.I16, 'start_gpu', None, None, ),  # 4
    (5, TType.STRING, 'host_name', 'UTF8', None, ),  # 5
    (6, TType.LIST, 'gpu_info', (TType.STRUCT, [TGpuSpecification, None], False), None, ),  # 6
)
all_structs.append(TClusterHardwareInfo)
TClusterHardwareInfo.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'hardware_info', (TType.STRUCT, [THardwareInfo, None], False), None, ),  # 1
)
all_structs.append(TMemoryData)
TMemoryData.thrift_spec = (
    None,  # 0
    (1, TType.I64, 'slab', None, None, ),  # 1
    (2, TType.I32, 'start_page', None, None, ),  # 2
    (3, TType.I64, 'num_pages', None, None, ),  # 3
    (4, TType.I32, 'touch', None, None, ),  # 4
    (5, TType.LIST, 'chunk_key', (TType.I64, None, False), None, ),  # 5
    (6, TType.I32, 'buffer_epoch', None, None, ),  # 6
    (7, TType.BOOL, 'is_free', None, None, ),  # 7
)
all_structs.append(TNodeMemoryInfo)
TNodeMemoryInfo.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'host_name', 'UTF8', None, ),  # 1
    (2, TType.I64, 'page_size', None, None, ),  # 2
    (3, TType.I64, 'max_num_pages', None, None, ),  # 3
    (4, TType.I64, 'num_pages_allocated', None, None, ),  # 4
    (5, TType.BOOL, 'is_allocation_capped', None, None, ),  # 5
    (6, TType.LIST, 'node_memory_data', (TType.STRUCT, [TMemoryData, None], False), None, ),  # 6
)
all_structs.append(TTableMeta)
TTableMeta.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'table_name', 'UTF8', None, ),  # 1
    (2, TType.I64, 'num_cols', None, None, ),  # 2
    None,  # 3
    (4, TType.BOOL, 'is_view', None, None, ),  # 4
    (5, TType.BOOL, 'is_replicated', None, None, ),  # 5
    (6, TType.I64, 'shard_count', None, None, ),  # 6
    (7, TType.I64, 'max_rows', None, None, ),  # 7
    (8, TType.I64, 'table_id', None, None, ),  # 8
    (9, TType.I64, 'max_table_id', None, None, ),  # 9
    (10, TType.LIST, 'col_types', (TType.STRUCT, [heavydb.common.ttypes.TTypeInfo, None], False), None, ),  # 10
    (11, TType.LIST, 'col_names', (TType.STRING, 'UTF8', False), None, ),  # 11
)
all_structs.append(TTableRefreshInfo)
TTableRefreshInfo.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'update_type', None, None, ),  # 1
    (2, TType.I32, 'timing_type', None, None, ),  # 2
    (3, TType.STRING, 'start_date_time', 'UTF8', None, ),  # 3
    (4, TType.I32, 'interval_type', None, None, ),  # 4
    (5, TType.I64, 'interval_count', None, None, ),  # 5
    (6, TType.STRING, 'last_refresh_time', 'UTF8', None, ),  # 6
    (7, TType.STRING, 'next_refresh_time', 'UTF8', None, ),  # 7
)
all_structs.append(TTableDetails)
TTableDetails.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'row_desc', (TType.STRUCT, [TColumnType, None], False), None, ),  # 1
    (2, TType.I64, 'fragment_size', None, None, ),  # 2
    (3, TType.I64, 'page_size', None, None, ),  # 3
    (4, TType.I64, 'max_rows', None, None, ),  # 4
    (5, TType.STRING, 'view_sql', 'UTF8', None, ),  # 5
    (6, TType.I64, 'shard_count', None, None, ),  # 6
    (7, TType.STRING, 'key_metainfo', 'UTF8', None, ),  # 7
    (8, TType.BOOL, 'is_temporary', None, None, ),  # 8
    (9, TType.I32, 'partition_detail', None, None, ),  # 9
    (10, TType.I32, 'table_type', None, None, ),  # 10
    (11, TType.STRUCT, 'refresh_info', [TTableRefreshInfo, None], None, ),  # 11
    (12, TType.STRING, 'sharded_column_name', 'UTF8', None, ),  # 12
)
all_structs.append(TColumnRange)
TColumnRange.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'type', None, None, ),  # 1
    (2, TType.I32, 'col_id', None, None, ),  # 2
    (3, TType.I32, 'table_id', None, None, ),  # 3
    (4, TType.BOOL, 'has_nulls', None, None, ),  # 4
    (5, TType.I64, 'int_min', None, None, ),  # 5
    (6, TType.I64, 'int_max', None, None, ),  # 6
    (7, TType.I64, 'bucket', None, None, ),  # 7
    (8, TType.DOUBLE, 'fp_min', None, None, ),  # 8
    (9, TType.DOUBLE, 'fp_max', None, None, ),  # 9
    (10, TType.I32, 'db_id', None, None, ),  # 10
)
all_structs.append(TDictionaryGeneration)
TDictionaryGeneration.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'dict_id', None, None, ),  # 1
    (2, TType.I64, 'entry_count', None, None, ),  # 2
    (3, TType.I32, 'db_id', None, None, ),  # 3
)
all_structs.append(TTableGeneration)
TTableGeneration.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'table_id', None, None, ),  # 1
    (2, TType.I64, 'tuple_count', None, None, ),  # 2
    (3, TType.I64, 'start_rowid', None, None, ),  # 3
    (4, TType.I32, 'db_id', None, None, ),  # 4
)
all_structs.append(TTableCacheStatus)
TTableCacheStatus.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'table_id', None, None, ),  # 1
    (2, TType.I32, 'db_id', None, None, ),  # 2
    (3, TType.BOOL, 'is_cached_on_disk', None, None, ),  # 3
)
all_structs.append(TPendingQuery)
TPendingQuery.thrift_spec = (
    None,  # 0
    (1, TType.I64, 'id', None, None, ),  # 1
    (2, TType.LIST, 'column_ranges', (TType.STRUCT, [TColumnRange, None], False), None, ),  # 2
    (3, TType.LIST, 'dictionary_generations', (TType.STRUCT, [TDictionaryGeneration, None], False), None, ),  # 3
    (4, TType.LIST, 'table_generations', (TType.STRUCT, [TTableGeneration, None], False), None, ),  # 4
    (5, TType.STRING, 'parent_session_id', 'UTF8', None, ),  # 5
    (6, TType.LIST, 'table_cache_status', (TType.STRUCT, [TTableCacheStatus, None], False), None, ),  # 6
)
all_structs.append(TVarLen)
TVarLen.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'payload', 'BINARY', None, ),  # 1
    (2, TType.BOOL, 'is_null', None, None, ),  # 2
)
all_structs.append(TDataBlockPtr)
TDataBlockPtr.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'fixed_len_data', 'BINARY', None, ),  # 1
    (2, TType.LIST, 'var_len_data', (TType.STRUCT, [TVarLen, None], False), None, ),  # 2
)
all_structs.append(TInsertData)
TInsertData.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'db_id', None, None, ),  # 1
    (2, TType.I32, 'table_id', None, None, ),  # 2
    (3, TType.LIST, 'column_ids', (TType.I32, None, False), None, ),  # 3
    (4, TType.LIST, 'data', (TType.STRUCT, [TDataBlockPtr, None], False), None, ),  # 4
    (5, TType.I64, 'num_rows', None, None, ),  # 5
    (6, TType.LIST, 'is_default', (TType.BOOL, None, False), None, ),  # 6
)
all_structs.append(TChunkData)
TChunkData.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'data_buffer', 'BINARY', None, ),  # 1
    (2, TType.STRING, 'index_buffer', 'BINARY', None, ),  # 2
)
all_structs.append(TInsertChunks)
TInsertChunks.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'db_id', None, None, ),  # 1
    (2, TType.I32, 'table_id', None, None, ),  # 2
    (3, TType.LIST, 'data', (TType.STRUCT, [TChunkData, None], False), None, ),  # 3
    (4, TType.LIST, 'valid_indices', (TType.I64, None, False), None, ),  # 4
    (5, TType.I64, 'num_rows', None, None, ),  # 5
)
all_structs.append(TPendingRenderQuery)
TPendingRenderQuery.thrift_spec = (
    None,  # 0
    (1, TType.I64, 'id', None, None, ),  # 1
)
all_structs.append(TRenderParseResult)
TRenderParseResult.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'merge_type', None, None, ),  # 1
    (2, TType.I32, 'node_id', None, None, ),  # 2
    (3, TType.I64, 'execution_time_ms', None, None, ),  # 3
    (4, TType.I64, 'render_time_ms', None, None, ),  # 4
    (5, TType.I64, 'total_time_ms', None, None, ),  # 5
)
all_structs.append(TRawRenderPassDataResult)
TRawRenderPassDataResult.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'num_pixel_channels', None, None, ),  # 1
    (2, TType.I32, 'num_pixel_samples', None, None, ),  # 2
    (3, TType.STRING, 'pixels', 'BINARY', None, ),  # 3
    (4, TType.STRING, 'row_ids_A', 'BINARY', None, ),  # 4
    (5, TType.STRING, 'row_ids_B', 'BINARY', None, ),  # 5
    (6, TType.STRING, 'table_ids', 'BINARY', None, ),  # 6
    (7, TType.STRING, 'accum_data', 'BINARY', None, ),  # 7
    (8, TType.I32, 'accum_depth', None, None, ),  # 8
)
all_structs.append(TRawPixelData)
TRawPixelData.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'width', None, None, ),  # 1
    (2, TType.I32, 'height', None, None, ),  # 2
    (3, TType.MAP, 'render_pass_map', (TType.I32, None, TType.STRUCT, [TRawRenderPassDataResult, None], False), None, ),  # 3
)
all_structs.append(TRenderDatum)
TRenderDatum.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'type', None, None, ),  # 1
    (2, TType.I32, 'cnt', None, None, ),  # 2
    (3, TType.STRING, 'value', 'BINARY', None, ),  # 3
)
all_structs.append(TRenderStepResult)
TRenderStepResult.thrift_spec = (
    None,  # 0
    (1, TType.MAP, 'merge_data', (TType.STRING, 'UTF8', TType.MAP, (TType.STRING, 'UTF8', TType.MAP, (TType.STRING, 'UTF8', TType.MAP, (TType.STRING, 'UTF8', TType.LIST, (TType.STRUCT, [TRenderDatum, None], False), False), False), False), False), None, ),  # 1
    (2, TType.STRUCT, 'raw_pixel_data', [TRawPixelData, None], None, ),  # 2
    (3, TType.I64, 'execution_time_ms', None, None, ),  # 3
    (4, TType.I64, 'render_time_ms', None, None, ),  # 4
    (5, TType.I64, 'total_time_ms', None, None, ),  # 5
)
all_structs.append(TDatabasePermissions)
TDatabasePermissions.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'create_', None, None, ),  # 1
    (2, TType.BOOL, 'delete_', None, None, ),  # 2
    (3, TType.BOOL, 'view_sql_editor_', None, None, ),  # 3
    (4, TType.BOOL, 'access_', None, None, ),  # 4
)
all_structs.append(TTablePermissions)
TTablePermissions.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'create_', None, None, ),  # 1
    (2, TType.BOOL, 'drop_', None, None, ),  # 2
    (3, TType.BOOL, 'select_', None, None, ),  # 3
    (4, TType.BOOL, 'insert_', None, None, ),  # 4
    (5, TType.BOOL, 'update_', None, None, ),  # 5
    (6, TType.BOOL, 'delete_', None, None, ),  # 6
    (7, TType.BOOL, 'truncate_', None, None, ),  # 7
    (8, TType.BOOL, 'alter_', None, None, ),  # 8
)
all_structs.append(TDashboardPermissions)
TDashboardPermissions.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'create_', None, None, ),  # 1
    (2, TType.BOOL, 'delete_', None, None, ),  # 2
    (3, TType.BOOL, 'view_', None, None, ),  # 3
    (4, TType.BOOL, 'edit_', None, None, ),  # 4
)
all_structs.append(TViewPermissions)
TViewPermissions.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'create_', None, None, ),  # 1
    (2, TType.BOOL, 'drop_', None, None, ),  # 2
    (3, TType.BOOL, 'select_', None, None, ),  # 3
    (4, TType.BOOL, 'insert_', None, None, ),  # 4
    (5, TType.BOOL, 'update_', None, None, ),  # 5
    (6, TType.BOOL, 'delete_', None, None, ),  # 6
)
all_structs.append(TServerPermissions)
TServerPermissions.thrift_spec = (
    None,  # 0
    (1, TType.BOOL, 'create_', None, None, ),  # 1
    (2, TType.BOOL, 'drop_', None, None, ),  # 2
    (3, TType.BOOL, 'alter_', None, None, ),  # 3
    (4, TType.BOOL, 'usage_', None, None, ),  # 4
)
all_structs.append(TDBObjectPermissions)
TDBObjectPermissions.thrift_spec = (
    None,  # 0
    (1, TType.STRUCT, 'database_permissions_', [TDatabasePermissions, None], None, ),  # 1
    (2, TType.STRUCT, 'table_permissions_', [TTablePermissions, None], None, ),  # 2
    (3, TType.STRUCT, 'dashboard_permissions_', [TDashboardPermissions, None], None, ),  # 3
    (4, TType.STRUCT, 'view_permissions_', [TViewPermissions, None], None, ),  # 4
    (5, TType.STRUCT, 'server_permissions_', [TServerPermissions, None], None, ),  # 5
)
all_structs.append(TDBObject)
TDBObject.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'objectName', 'UTF8', None, ),  # 1
    (2, TType.I32, 'objectType', None, None, ),  # 2
    (3, TType.LIST, 'privs', (TType.BOOL, None, False), None, ),  # 3
    (4, TType.STRING, 'grantee', 'UTF8', None, ),  # 4
    (5, TType.I32, 'privilegeObjectType', None, None, ),  # 5
    (6, TType.I32, 'objectId', None, None, ),  # 6
)
all_structs.append(TDashboardGrantees)
TDashboardGrantees.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'name', 'UTF8', None, ),  # 1
    (2, TType.BOOL, 'is_user', None, None, ),  # 2
    (3, TType.STRUCT, 'permissions', [TDashboardPermissions, None], None, ),  # 3
)
all_structs.append(TDashboard)
TDashboard.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'dashboard_name', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'dashboard_state', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'image_hash', 'UTF8', None, ),  # 3
    (4, TType.STRING, 'update_time', 'UTF8', None, ),  # 4
    (5, TType.STRING, 'dashboard_metadata', 'UTF8', None, ),  # 5
    (6, TType.I32, 'dashboard_id', None, None, ),  # 6
    (7, TType.STRING, 'dashboard_owner', 'UTF8', None, ),  # 7
    (8, TType.BOOL, 'is_dash_shared', None, None, ),  # 8
    (9, TType.STRUCT, 'dashboard_permissions', [TDashboardPermissions, None], None, ),  # 9
)
all_structs.append(TLicenseInfo)
TLicenseInfo.thrift_spec = (
    None,  # 0
    (1, TType.LIST, 'claims', (TType.STRING, 'UTF8', False), None, ),  # 1
)
all_structs.append(TSessionInfo)
TSessionInfo.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'user', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'database', 'UTF8', None, ),  # 2
    (3, TType.I64, 'start_time', None, None, ),  # 3
    (4, TType.BOOL, 'is_super', None, None, ),  # 4
)
all_structs.append(TGeoFileLayerInfo)
TGeoFileLayerInfo.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'name', 'UTF8', None, ),  # 1
    (2, TType.I32, 'contents', None, None, ),  # 2
)
all_structs.append(TTableEpochInfo)
TTableEpochInfo.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'table_id', None, None, ),  # 1
    (2, TType.I32, 'table_epoch', None, None, ),  # 2
    (3, TType.I32, 'leaf_index', None, None, ),  # 3
)
all_structs.append(TCustomExpression)
TCustomExpression.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'id', None, None, ),  # 1
    (2, TType.STRING, 'name', 'UTF8', None, ),  # 2
    None,  # 3
    (4, TType.STRING, 'expression_json', 'UTF8', None, ),  # 4
    (5, TType.I32, 'data_source_type', None, None, ),  # 5
    (6, TType.I32, 'data_source_id', None, None, ),  # 6
    (7, TType.BOOL, 'is_deleted', None, None, ),  # 7
    (8, TType.STRING, 'data_source_name', 'UTF8', None, ),  # 8
)
all_structs.append(TQueryInfo)
TQueryInfo.thrift_spec = (
    None,  # 0
    (1, TType.STRING, 'query_session_id', 'UTF8', None, ),  # 1
    (2, TType.STRING, 'query_public_session_id', 'UTF8', None, ),  # 2
    (3, TType.STRING, 'current_status', 'UTF8', None, ),  # 3
    (4, TType.I32, 'executor_id', None, None, ),  # 4
    (5, TType.STRING, 'submitted', 'UTF8', None, ),  # 5
    (6, TType.STRING, 'query_str', 'UTF8', None, ),  # 6
    (7, TType.STRING, 'login_name', 'UTF8', None, ),  # 7
    (8, TType.STRING, 'client_address', 'UTF8', None, ),  # 8
    (9, TType.STRING, 'db_name', 'UTF8', None, ),  # 9
    (10, TType.STRING, 'exec_device_type', 'UTF8', None, ),  # 10
)
all_structs.append(TLeafInfo)
TLeafInfo.thrift_spec = (
    None,  # 0
    (1, TType.I32, 'leaf_id', None, None, ),  # 1
    (2, TType.I32, 'num_leaves', None, None, ),  # 2
)
fix_spec(all_structs)
del all_structs