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