ttypes.py

Go to the documentation of this file.

#
# Autogenerated by Thrift Compiler (0.13.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 omnisci.common.ttypes
import omnisci.completion_hints.ttypes
import omnisci.serialized_result_set.ttypes
import omnisci.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 TFileType(object):
    DELIMITED = 0
    POLYGON = 1
    PARQUET = 2

    _VALUES_TO_NAMES = {
        0: "DELIMITED",
        1: "POLYGON",
        2: "PARQUET",
    }

    _NAMES_TO_VALUES = {
        "DELIMITED": 0,
        "POLYGON": 1,
        "PARQUET": 2,
    }


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 TMergeType(object):
    UNION = 0
    REDUCE = 1

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

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


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

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

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


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') 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') 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

    """


    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,):
        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

    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') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.col_type = omnisci.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') 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)
            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()
        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') 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') 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') 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 = omnisci.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') 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') 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') 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') 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 TOmniSciException(TException):
    """
    Attributes:
     - error_msg

    """


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

    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.error_msg = iprot.readString().decode('utf-8') 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('TOmniSciException')
        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
     - file_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

    """


    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, file_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=True, geo_explode_collections=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.file_type = file_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

    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') 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') 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') 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') 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') 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') 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') 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') 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.file_type = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 13:
                if ftype == TType.STRING:
                    self.s3_access_key = iprot.readString().decode('utf-8') 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') 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') 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') 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') 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)
            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.file_type is not None:
            oprot.writeFieldBegin('file_type', TType.I32, 12)
            oprot.writeI32(self.file_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()
        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') 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') 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') 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') 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') 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 TDashboard(object):
    """
    Attributes:
     - dashboard_name
     - dashboard_state
     - image_hash
     - update_time
     - dashboard_metadata
     - dashboard_id
     - dashboard_owner
     - is_dash_shared

    """


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

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

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

    """


    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,):
        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

    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') 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') 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') 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)
            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()
        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') 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') 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') 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') 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') 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') 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') 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 = omnisci.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') 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 TTableDetails(object):
    """
    Attributes:
     - row_desc
     - fragment_size
     - page_size
     - max_rows
     - view_sql
     - shard_count
     - key_metainfo
     - is_temporary
     - partition_detail

    """


    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,):
        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

    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') 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') 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)
            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()
        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

    """


    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,):
        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

    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)
            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()
        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

    """


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

    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)
            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()
        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

    """


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

    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)
            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()
        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

    """


    def __init__(self, id=None, column_ranges=None, dictionary_generations=None, table_generations=None, parent_session_id=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

    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') 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('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 iter165 in self.column_ranges:
                iter165.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 iter166 in self.dictionary_generations:
                iter166.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 iter167 in self.table_generations:
                iter167.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()
        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 = []
                    (_etype171, _size168) = iprot.readListBegin()
                    for _i172 in range(_size168):
                        _elem173 = TVarLen()
                        _elem173.read(iprot)
                        self.var_len_data.append(_elem173)
                    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 iter174 in self.var_len_data:
                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 TInsertData(object):
    """
    Attributes:
     - db_id
     - table_id
     - column_ids
     - data
     - num_rows

    """


    def __init__(self, db_id=None, table_id=None, column_ids=None, data=None, num_rows=None,):
        self.db_id = db_id
        self.table_id = table_id
        self.column_ids = column_ids
        self.data = data
        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.column_ids = []
                    (_etype178, _size175) = iprot.readListBegin()
                    for _i179 in range(_size175):
                        _elem180 = iprot.readI32()
                        self.column_ids.append(_elem180)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.data = []
                    (_etype184, _size181) = iprot.readListBegin()
                    for _i185 in range(_size181):
                        _elem186 = TDataBlockPtr()
                        _elem186.read(iprot)
                        self.data.append(_elem186)
                    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('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 iter187 in self.column_ids:
                oprot.writeI32(iter187)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.data is not None:
            oprot.writeFieldBegin('data', TType.LIST, 4)
            oprot.writeListBegin(TType.STRUCT, len(self.data))
            for iter188 in self.data:
                iter188.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()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

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

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

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


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

    """


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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 1:
                if ftype == TType.MAP:
                    self.merge_data = {}
                    (_ktype199, _vtype200, _size198) = iprot.readMapBegin()
                    for _i202 in range(_size198):
                        _key203 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val204 = {}
                        (_ktype206, _vtype207, _size205) = iprot.readMapBegin()
                        for _i209 in range(_size205):
                            _key210 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                            _val211 = {}
                            (_ktype213, _vtype214, _size212) = iprot.readMapBegin()
                            for _i216 in range(_size212):
                                _key217 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                                _val218 = {}
                                (_ktype220, _vtype221, _size219) = iprot.readMapBegin()
                                for _i223 in range(_size219):
                                    _key224 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                                    _val225 = []
                                    (_etype229, _size226) = iprot.readListBegin()
                                    for _i230 in range(_size226):
                                        _elem231 = TRenderDatum()
                                        _elem231.read(iprot)
                                        _val225.append(_elem231)
                                    iprot.readListEnd()
                                    _val218[_key224] = _val225
                                iprot.readMapEnd()
                                _val211[_key217] = _val218
                            iprot.readMapEnd()
                            _val204[_key210] = _val211
                        iprot.readMapEnd()
                        self.merge_data[_key203] = _val204
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.raw_pixel_data = TRawPixelData()
                    self.raw_pixel_data.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I64:
                    self.execution_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I64:
                    self.render_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I64:
                    self.total_time_ms = iprot.readI64()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
            return
        oprot.writeStructBegin('TRenderStepResult')
        if self.merge_data is not None:
            oprot.writeFieldBegin('merge_data', TType.MAP, 1)
            oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.merge_data))
            for kiter232, viter233 in self.merge_data.items():
                oprot.writeString(kiter232.encode('utf-8') if sys.version_info[0] == 2 else kiter232)
                oprot.writeMapBegin(TType.STRING, TType.MAP, len(viter233))
                for kiter234, viter235 in viter233.items():
                    oprot.writeString(kiter234.encode('utf-8') if sys.version_info[0] == 2 else kiter234)
                    oprot.writeMapBegin(TType.STRING, TType.MAP, len(viter235))
                    for kiter236, viter237 in viter235.items():
                        oprot.writeString(kiter236.encode('utf-8') if sys.version_info[0] == 2 else kiter236)
                        oprot.writeMapBegin(TType.STRING, TType.LIST, len(viter237))
                        for kiter238, viter239 in viter237.items():
                            oprot.writeString(kiter238.encode('utf-8') if sys.version_info[0] == 2 else kiter238)
                            oprot.writeListBegin(TType.STRUCT, len(viter239))
                            for iter240 in viter239:
                                iter240.write(oprot)
                            oprot.writeListEnd()
                        oprot.writeMapEnd()
                    oprot.writeMapEnd()
                oprot.writeMapEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.raw_pixel_data is not None:
            oprot.writeFieldBegin('raw_pixel_data', TType.STRUCT, 2)
            self.raw_pixel_data.write(oprot)
            oprot.writeFieldEnd()
        if self.execution_time_ms is not None:
            oprot.writeFieldBegin('execution_time_ms', TType.I64, 3)
            oprot.writeI64(self.execution_time_ms)
            oprot.writeFieldEnd()
        if self.render_time_ms is not None:
            oprot.writeFieldBegin('render_time_ms', TType.I64, 4)
            oprot.writeI64(self.render_time_ms)
            oprot.writeFieldEnd()
        if self.total_time_ms is not None:
            oprot.writeFieldBegin('total_time_ms', TType.I64, 5)
            oprot.writeI64(self.total_time_ms)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

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

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

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


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

    """


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

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

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

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)