ttypes.go

// Autogenerated by Thrift Compiler (0.9.2)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

package goshine

import (
	"bytes"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

var GoUnusedProtection__ int

type TProtocolVersion int64

const (
	TProtocolVersion_HIVE_CLI_SERVICE_PROTOCOL_V1 TProtocolVersion = 0
)

func (p TProtocolVersion) String() string {
	switch p {
	case TProtocolVersion_HIVE_CLI_SERVICE_PROTOCOL_V1:
		return "TProtocolVersion_HIVE_CLI_SERVICE_PROTOCOL_V1"
	}
	return "<UNSET>"
}

func TProtocolVersionFromString(s string) (TProtocolVersion, error) {
	switch s {
	case "TProtocolVersion_HIVE_CLI_SERVICE_PROTOCOL_V1":
		return TProtocolVersion_HIVE_CLI_SERVICE_PROTOCOL_V1, nil
	}
	return TProtocolVersion(0), fmt.Errorf("not a valid TProtocolVersion string")
}

func TProtocolVersionPtr(v TProtocolVersion) *TProtocolVersion { return &v }

type TTypeId int64

const (
	TTypeId_BOOLEAN_TYPE      TTypeId = 0
	TTypeId_TINYINT_TYPE      TTypeId = 1
	TTypeId_SMALLINT_TYPE     TTypeId = 2
	TTypeId_INT_TYPE          TTypeId = 3
	TTypeId_BIGINT_TYPE       TTypeId = 4
	TTypeId_FLOAT_TYPE        TTypeId = 5
	TTypeId_DOUBLE_TYPE       TTypeId = 6
	TTypeId_STRING_TYPE       TTypeId = 7
	TTypeId_TIMESTAMP_TYPE    TTypeId = 8
	TTypeId_BINARY_TYPE       TTypeId = 9
	TTypeId_ARRAY_TYPE        TTypeId = 10
	TTypeId_MAP_TYPE          TTypeId = 11
	TTypeId_STRUCT_TYPE       TTypeId = 12
	TTypeId_UNION_TYPE        TTypeId = 13
	TTypeId_USER_DEFINED_TYPE TTypeId = 14
	TTypeId_DECIMAL_TYPE      TTypeId = 15
	TTypeId_NULL_TYPE         TTypeId = 16
	TTypeId_DATE_TYPE         TTypeId = 17
	TTypeId_VARCHAR_TYPE      TTypeId = 18
	TTypeId_CHAR_TYPE         TTypeId = 19
)

func (p TTypeId) String() string {
	switch p {
	case TTypeId_BOOLEAN_TYPE:
		return "TTypeId_BOOLEAN_TYPE"
	case TTypeId_TINYINT_TYPE:
		return "TTypeId_TINYINT_TYPE"
	case TTypeId_SMALLINT_TYPE:
		return "TTypeId_SMALLINT_TYPE"
	case TTypeId_INT_TYPE:
		return "TTypeId_INT_TYPE"
	case TTypeId_BIGINT_TYPE:
		return "TTypeId_BIGINT_TYPE"
	case TTypeId_FLOAT_TYPE:
		return "TTypeId_FLOAT_TYPE"
	case TTypeId_DOUBLE_TYPE:
		return "TTypeId_DOUBLE_TYPE"
	case TTypeId_STRING_TYPE:
		return "TTypeId_STRING_TYPE"
	case TTypeId_TIMESTAMP_TYPE:
		return "TTypeId_TIMESTAMP_TYPE"
	case TTypeId_BINARY_TYPE:
		return "TTypeId_BINARY_TYPE"
	case TTypeId_ARRAY_TYPE:
		return "TTypeId_ARRAY_TYPE"
	case TTypeId_MAP_TYPE:
		return "TTypeId_MAP_TYPE"
	case TTypeId_STRUCT_TYPE:
		return "TTypeId_STRUCT_TYPE"
	case TTypeId_UNION_TYPE:
		return "TTypeId_UNION_TYPE"
	case TTypeId_USER_DEFINED_TYPE:
		return "TTypeId_USER_DEFINED_TYPE"
	case TTypeId_DECIMAL_TYPE:
		return "TTypeId_DECIMAL_TYPE"
	case TTypeId_NULL_TYPE:
		return "TTypeId_NULL_TYPE"
	case TTypeId_DATE_TYPE:
		return "TTypeId_DATE_TYPE"
	case TTypeId_VARCHAR_TYPE:
		return "TTypeId_VARCHAR_TYPE"
	case TTypeId_CHAR_TYPE:
		return "TTypeId_CHAR_TYPE"
	}
	return "<UNSET>"
}

func TTypeIdFromString(s string) (TTypeId, error) {
	switch s {
	case "TTypeId_BOOLEAN_TYPE":
		return TTypeId_BOOLEAN_TYPE, nil
	case "TTypeId_TINYINT_TYPE":
		return TTypeId_TINYINT_TYPE, nil
	case "TTypeId_SMALLINT_TYPE":
		return TTypeId_SMALLINT_TYPE, nil
	case "TTypeId_INT_TYPE":
		return TTypeId_INT_TYPE, nil
	case "TTypeId_BIGINT_TYPE":
		return TTypeId_BIGINT_TYPE, nil
	case "TTypeId_FLOAT_TYPE":
		return TTypeId_FLOAT_TYPE, nil
	case "TTypeId_DOUBLE_TYPE":
		return TTypeId_DOUBLE_TYPE, nil
	case "TTypeId_STRING_TYPE":
		return TTypeId_STRING_TYPE, nil
	case "TTypeId_TIMESTAMP_TYPE":
		return TTypeId_TIMESTAMP_TYPE, nil
	case "TTypeId_BINARY_TYPE":
		return TTypeId_BINARY_TYPE, nil
	case "TTypeId_ARRAY_TYPE":
		return TTypeId_ARRAY_TYPE, nil
	case "TTypeId_MAP_TYPE":
		return TTypeId_MAP_TYPE, nil
	case "TTypeId_STRUCT_TYPE":
		return TTypeId_STRUCT_TYPE, nil
	case "TTypeId_UNION_TYPE":
		return TTypeId_UNION_TYPE, nil
	case "TTypeId_USER_DEFINED_TYPE":
		return TTypeId_USER_DEFINED_TYPE, nil
	case "TTypeId_DECIMAL_TYPE":
		return TTypeId_DECIMAL_TYPE, nil
	case "TTypeId_NULL_TYPE":
		return TTypeId_NULL_TYPE, nil
	case "TTypeId_DATE_TYPE":
		return TTypeId_DATE_TYPE, nil
	case "TTypeId_VARCHAR_TYPE":
		return TTypeId_VARCHAR_TYPE, nil
	case "TTypeId_CHAR_TYPE":
		return TTypeId_CHAR_TYPE, nil
	}
	return TTypeId(0), fmt.Errorf("not a valid TTypeId string")
}

func TTypeIdPtr(v TTypeId) *TTypeId { return &v }

type TStatusCode int64

const (
	TStatusCode_SUCCESS_STATUS           TStatusCode = 0
	TStatusCode_SUCCESS_WITH_INFO_STATUS TStatusCode = 1
	TStatusCode_STILL_EXECUTING_STATUS   TStatusCode = 2
	TStatusCode_ERROR_STATUS             TStatusCode = 3
	TStatusCode_INVALID_HANDLE_STATUS    TStatusCode = 4
)

func (p TStatusCode) String() string {
	switch p {
	case TStatusCode_SUCCESS_STATUS:
		return "TStatusCode_SUCCESS_STATUS"
	case TStatusCode_SUCCESS_WITH_INFO_STATUS:
		return "TStatusCode_SUCCESS_WITH_INFO_STATUS"
	case TStatusCode_STILL_EXECUTING_STATUS:
		return "TStatusCode_STILL_EXECUTING_STATUS"
	case TStatusCode_ERROR_STATUS:
		return "TStatusCode_ERROR_STATUS"
	case TStatusCode_INVALID_HANDLE_STATUS:
		return "TStatusCode_INVALID_HANDLE_STATUS"
	}
	return "<UNSET>"
}

func TStatusCodeFromString(s string) (TStatusCode, error) {
	switch s {
	case "TStatusCode_SUCCESS_STATUS":
		return TStatusCode_SUCCESS_STATUS, nil
	case "TStatusCode_SUCCESS_WITH_INFO_STATUS":
		return TStatusCode_SUCCESS_WITH_INFO_STATUS, nil
	case "TStatusCode_STILL_EXECUTING_STATUS":
		return TStatusCode_STILL_EXECUTING_STATUS, nil
	case "TStatusCode_ERROR_STATUS":
		return TStatusCode_ERROR_STATUS, nil
	case "TStatusCode_INVALID_HANDLE_STATUS":
		return TStatusCode_INVALID_HANDLE_STATUS, nil
	}
	return TStatusCode(0), fmt.Errorf("not a valid TStatusCode string")
}

func TStatusCodePtr(v TStatusCode) *TStatusCode { return &v }

type TOperationState int64

const (
	TOperationState_INITIALIZED_STATE TOperationState = 0
	TOperationState_RUNNING_STATE     TOperationState = 1
	TOperationState_FINISHED_STATE    TOperationState = 2
	TOperationState_CANCELED_STATE    TOperationState = 3
	TOperationState_CLOSED_STATE      TOperationState = 4
	TOperationState_ERROR_STATE       TOperationState = 5
	TOperationState_UKNOWN_STATE      TOperationState = 6
)

func (p TOperationState) String() string {
	switch p {
	case TOperationState_INITIALIZED_STATE:
		return "TOperationState_INITIALIZED_STATE"
	case TOperationState_RUNNING_STATE:
		return "TOperationState_RUNNING_STATE"
	case TOperationState_FINISHED_STATE:
		return "TOperationState_FINISHED_STATE"
	case TOperationState_CANCELED_STATE:
		return "TOperationState_CANCELED_STATE"
	case TOperationState_CLOSED_STATE:
		return "TOperationState_CLOSED_STATE"
	case TOperationState_ERROR_STATE:
		return "TOperationState_ERROR_STATE"
	case TOperationState_UKNOWN_STATE:
		return "TOperationState_UKNOWN_STATE"
	}
	return "<UNSET>"
}

func TOperationStateFromString(s string) (TOperationState, error) {
	switch s {
	case "TOperationState_INITIALIZED_STATE":
		return TOperationState_INITIALIZED_STATE, nil
	case "TOperationState_RUNNING_STATE":
		return TOperationState_RUNNING_STATE, nil
	case "TOperationState_FINISHED_STATE":
		return TOperationState_FINISHED_STATE, nil
	case "TOperationState_CANCELED_STATE":
		return TOperationState_CANCELED_STATE, nil
	case "TOperationState_CLOSED_STATE":
		return TOperationState_CLOSED_STATE, nil
	case "TOperationState_ERROR_STATE":
		return TOperationState_ERROR_STATE, nil
	case "TOperationState_UKNOWN_STATE":
		return TOperationState_UKNOWN_STATE, nil
	}
	return TOperationState(0), fmt.Errorf("not a valid TOperationState string")
}

func TOperationStatePtr(v TOperationState) *TOperationState { return &v }

type TOperationType int64

const (
	TOperationType_EXECUTE_STATEMENT TOperationType = 0
	TOperationType_GET_TYPE_INFO     TOperationType = 1
	TOperationType_GET_CATALOGS      TOperationType = 2
	TOperationType_GET_SCHEMAS       TOperationType = 3
	TOperationType_GET_TABLES        TOperationType = 4
	TOperationType_GET_TABLE_TYPES   TOperationType = 5
	TOperationType_GET_COLUMNS       TOperationType = 6
	TOperationType_GET_FUNCTIONS     TOperationType = 7
	TOperationType_UNKNOWN           TOperationType = 8
)

func (p TOperationType) String() string {
	switch p {
	case TOperationType_EXECUTE_STATEMENT:
		return "TOperationType_EXECUTE_STATEMENT"
	case TOperationType_GET_TYPE_INFO:
		return "TOperationType_GET_TYPE_INFO"
	case TOperationType_GET_CATALOGS:
		return "TOperationType_GET_CATALOGS"
	case TOperationType_GET_SCHEMAS:
		return "TOperationType_GET_SCHEMAS"
	case TOperationType_GET_TABLES:
		return "TOperationType_GET_TABLES"
	case TOperationType_GET_TABLE_TYPES:
		return "TOperationType_GET_TABLE_TYPES"
	case TOperationType_GET_COLUMNS:
		return "TOperationType_GET_COLUMNS"
	case TOperationType_GET_FUNCTIONS:
		return "TOperationType_GET_FUNCTIONS"
	case TOperationType_UNKNOWN:
		return "TOperationType_UNKNOWN"
	}
	return "<UNSET>"
}

func TOperationTypeFromString(s string) (TOperationType, error) {
	switch s {
	case "TOperationType_EXECUTE_STATEMENT":
		return TOperationType_EXECUTE_STATEMENT, nil
	case "TOperationType_GET_TYPE_INFO":
		return TOperationType_GET_TYPE_INFO, nil
	case "TOperationType_GET_CATALOGS":
		return TOperationType_GET_CATALOGS, nil
	case "TOperationType_GET_SCHEMAS":
		return TOperationType_GET_SCHEMAS, nil
	case "TOperationType_GET_TABLES":
		return TOperationType_GET_TABLES, nil
	case "TOperationType_GET_TABLE_TYPES":
		return TOperationType_GET_TABLE_TYPES, nil
	case "TOperationType_GET_COLUMNS":
		return TOperationType_GET_COLUMNS, nil
	case "TOperationType_GET_FUNCTIONS":
		return TOperationType_GET_FUNCTIONS, nil
	case "TOperationType_UNKNOWN":
		return TOperationType_UNKNOWN, nil
	}
	return TOperationType(0), fmt.Errorf("not a valid TOperationType string")
}

func TOperationTypePtr(v TOperationType) *TOperationType { return &v }

type TGetInfoType int64

const (
	TGetInfoType_CLI_MAX_DRIVER_CONNECTIONS     TGetInfoType = 0
	TGetInfoType_CLI_MAX_CONCURRENT_ACTIVITIES  TGetInfoType = 1
	TGetInfoType_CLI_DATA_SOURCE_NAME           TGetInfoType = 2
	TGetInfoType_CLI_FETCH_DIRECTION            TGetInfoType = 8
	TGetInfoType_CLI_SERVER_NAME                TGetInfoType = 13
	TGetInfoType_CLI_SEARCH_PATTERN_ESCAPE      TGetInfoType = 14
	TGetInfoType_CLI_DBMS_NAME                  TGetInfoType = 17
	TGetInfoType_CLI_DBMS_VER                   TGetInfoType = 18
	TGetInfoType_CLI_ACCESSIBLE_TABLES          TGetInfoType = 19
	TGetInfoType_CLI_ACCESSIBLE_PROCEDURES      TGetInfoType = 20
	TGetInfoType_CLI_CURSOR_COMMIT_BEHAVIOR     TGetInfoType = 23
	TGetInfoType_CLI_DATA_SOURCE_READ_ONLY      TGetInfoType = 25
	TGetInfoType_CLI_DEFAULT_TXN_ISOLATION      TGetInfoType = 26
	TGetInfoType_CLI_IDENTIFIER_CASE            TGetInfoType = 28
	TGetInfoType_CLI_IDENTIFIER_QUOTE_CHAR      TGetInfoType = 29
	TGetInfoType_CLI_MAX_COLUMN_NAME_LEN        TGetInfoType = 30
	TGetInfoType_CLI_MAX_CURSOR_NAME_LEN        TGetInfoType = 31
	TGetInfoType_CLI_MAX_SCHEMA_NAME_LEN        TGetInfoType = 32
	TGetInfoType_CLI_MAX_CATALOG_NAME_LEN       TGetInfoType = 34
	TGetInfoType_CLI_MAX_TABLE_NAME_LEN         TGetInfoType = 35
	TGetInfoType_CLI_SCROLL_CONCURRENCY         TGetInfoType = 43
	TGetInfoType_CLI_TXN_CAPABLE                TGetInfoType = 46
	TGetInfoType_CLI_USER_NAME                  TGetInfoType = 47
	TGetInfoType_CLI_TXN_ISOLATION_OPTION       TGetInfoType = 72
	TGetInfoType_CLI_INTEGRITY                  TGetInfoType = 73
	TGetInfoType_CLI_GETDATA_EXTENSIONS         TGetInfoType = 81
	TGetInfoType_CLI_NULL_COLLATION             TGetInfoType = 85
	TGetInfoType_CLI_ALTER_TABLE                TGetInfoType = 86
	TGetInfoType_CLI_ORDER_BY_COLUMNS_IN_SELECT TGetInfoType = 90
	TGetInfoType_CLI_SPECIAL_CHARACTERS         TGetInfoType = 94
	TGetInfoType_CLI_MAX_COLUMNS_IN_GROUP_BY    TGetInfoType = 97
	TGetInfoType_CLI_MAX_COLUMNS_IN_INDEX       TGetInfoType = 98
	TGetInfoType_CLI_MAX_COLUMNS_IN_ORDER_BY    TGetInfoType = 99
	TGetInfoType_CLI_MAX_COLUMNS_IN_SELECT      TGetInfoType = 100
	TGetInfoType_CLI_MAX_COLUMNS_IN_TABLE       TGetInfoType = 101
	TGetInfoType_CLI_MAX_INDEX_SIZE             TGetInfoType = 102
	TGetInfoType_CLI_MAX_ROW_SIZE               TGetInfoType = 104
	TGetInfoType_CLI_MAX_STATEMENT_LEN          TGetInfoType = 105
	TGetInfoType_CLI_MAX_TABLES_IN_SELECT       TGetInfoType = 106
	TGetInfoType_CLI_MAX_USER_NAME_LEN          TGetInfoType = 107
	TGetInfoType_CLI_OJ_CAPABILITIES            TGetInfoType = 115
	TGetInfoType_CLI_XOPEN_CLI_YEAR             TGetInfoType = 10000
	TGetInfoType_CLI_CURSOR_SENSITIVITY         TGetInfoType = 10001
	TGetInfoType_CLI_DESCRIBE_PARAMETER         TGetInfoType = 10002
	TGetInfoType_CLI_CATALOG_NAME               TGetInfoType = 10003
	TGetInfoType_CLI_COLLATION_SEQ              TGetInfoType = 10004
	TGetInfoType_CLI_MAX_IDENTIFIER_LEN         TGetInfoType = 10005
)

func (p TGetInfoType) String() string {
	switch p {
	case TGetInfoType_CLI_MAX_DRIVER_CONNECTIONS:
		return "TGetInfoType_CLI_MAX_DRIVER_CONNECTIONS"
	case TGetInfoType_CLI_MAX_CONCURRENT_ACTIVITIES:
		return "TGetInfoType_CLI_MAX_CONCURRENT_ACTIVITIES"
	case TGetInfoType_CLI_DATA_SOURCE_NAME:
		return "TGetInfoType_CLI_DATA_SOURCE_NAME"
	case TGetInfoType_CLI_FETCH_DIRECTION:
		return "TGetInfoType_CLI_FETCH_DIRECTION"
	case TGetInfoType_CLI_SERVER_NAME:
		return "TGetInfoType_CLI_SERVER_NAME"
	case TGetInfoType_CLI_SEARCH_PATTERN_ESCAPE:
		return "TGetInfoType_CLI_SEARCH_PATTERN_ESCAPE"
	case TGetInfoType_CLI_DBMS_NAME:
		return "TGetInfoType_CLI_DBMS_NAME"
	case TGetInfoType_CLI_DBMS_VER:
		return "TGetInfoType_CLI_DBMS_VER"
	case TGetInfoType_CLI_ACCESSIBLE_TABLES:
		return "TGetInfoType_CLI_ACCESSIBLE_TABLES"
	case TGetInfoType_CLI_ACCESSIBLE_PROCEDURES:
		return "TGetInfoType_CLI_ACCESSIBLE_PROCEDURES"
	case TGetInfoType_CLI_CURSOR_COMMIT_BEHAVIOR:
		return "TGetInfoType_CLI_CURSOR_COMMIT_BEHAVIOR"
	case TGetInfoType_CLI_DATA_SOURCE_READ_ONLY:
		return "TGetInfoType_CLI_DATA_SOURCE_READ_ONLY"
	case TGetInfoType_CLI_DEFAULT_TXN_ISOLATION:
		return "TGetInfoType_CLI_DEFAULT_TXN_ISOLATION"
	case TGetInfoType_CLI_IDENTIFIER_CASE:
		return "TGetInfoType_CLI_IDENTIFIER_CASE"
	case TGetInfoType_CLI_IDENTIFIER_QUOTE_CHAR:
		return "TGetInfoType_CLI_IDENTIFIER_QUOTE_CHAR"
	case TGetInfoType_CLI_MAX_COLUMN_NAME_LEN:
		return "TGetInfoType_CLI_MAX_COLUMN_NAME_LEN"
	case TGetInfoType_CLI_MAX_CURSOR_NAME_LEN:
		return "TGetInfoType_CLI_MAX_CURSOR_NAME_LEN"
	case TGetInfoType_CLI_MAX_SCHEMA_NAME_LEN:
		return "TGetInfoType_CLI_MAX_SCHEMA_NAME_LEN"
	case TGetInfoType_CLI_MAX_CATALOG_NAME_LEN:
		return "TGetInfoType_CLI_MAX_CATALOG_NAME_LEN"
	case TGetInfoType_CLI_MAX_TABLE_NAME_LEN:
		return "TGetInfoType_CLI_MAX_TABLE_NAME_LEN"
	case TGetInfoType_CLI_SCROLL_CONCURRENCY:
		return "TGetInfoType_CLI_SCROLL_CONCURRENCY"
	case TGetInfoType_CLI_TXN_CAPABLE:
		return "TGetInfoType_CLI_TXN_CAPABLE"
	case TGetInfoType_CLI_USER_NAME:
		return "TGetInfoType_CLI_USER_NAME"
	case TGetInfoType_CLI_TXN_ISOLATION_OPTION:
		return "TGetInfoType_CLI_TXN_ISOLATION_OPTION"
	case TGetInfoType_CLI_INTEGRITY:
		return "TGetInfoType_CLI_INTEGRITY"
	case TGetInfoType_CLI_GETDATA_EXTENSIONS:
		return "TGetInfoType_CLI_GETDATA_EXTENSIONS"
	case TGetInfoType_CLI_NULL_COLLATION:
		return "TGetInfoType_CLI_NULL_COLLATION"
	case TGetInfoType_CLI_ALTER_TABLE:
		return "TGetInfoType_CLI_ALTER_TABLE"
	case TGetInfoType_CLI_ORDER_BY_COLUMNS_IN_SELECT:
		return "TGetInfoType_CLI_ORDER_BY_COLUMNS_IN_SELECT"
	case TGetInfoType_CLI_SPECIAL_CHARACTERS:
		return "TGetInfoType_CLI_SPECIAL_CHARACTERS"
	case TGetInfoType_CLI_MAX_COLUMNS_IN_GROUP_BY:
		return "TGetInfoType_CLI_MAX_COLUMNS_IN_GROUP_BY"
	case TGetInfoType_CLI_MAX_COLUMNS_IN_INDEX:
		return "TGetInfoType_CLI_MAX_COLUMNS_IN_INDEX"
	case TGetInfoType_CLI_MAX_COLUMNS_IN_ORDER_BY:
		return "TGetInfoType_CLI_MAX_COLUMNS_IN_ORDER_BY"
	case TGetInfoType_CLI_MAX_COLUMNS_IN_SELECT:
		return "TGetInfoType_CLI_MAX_COLUMNS_IN_SELECT"
	case TGetInfoType_CLI_MAX_COLUMNS_IN_TABLE:
		return "TGetInfoType_CLI_MAX_COLUMNS_IN_TABLE"
	case TGetInfoType_CLI_MAX_INDEX_SIZE:
		return "TGetInfoType_CLI_MAX_INDEX_SIZE"
	case TGetInfoType_CLI_MAX_ROW_SIZE:
		return "TGetInfoType_CLI_MAX_ROW_SIZE"
	case TGetInfoType_CLI_MAX_STATEMENT_LEN:
		return "TGetInfoType_CLI_MAX_STATEMENT_LEN"
	case TGetInfoType_CLI_MAX_TABLES_IN_SELECT:
		return "TGetInfoType_CLI_MAX_TABLES_IN_SELECT"
	case TGetInfoType_CLI_MAX_USER_NAME_LEN:
		return "TGetInfoType_CLI_MAX_USER_NAME_LEN"
	case TGetInfoType_CLI_OJ_CAPABILITIES:
		return "TGetInfoType_CLI_OJ_CAPABILITIES"
	case TGetInfoType_CLI_XOPEN_CLI_YEAR:
		return "TGetInfoType_CLI_XOPEN_CLI_YEAR"
	case TGetInfoType_CLI_CURSOR_SENSITIVITY:
		return "TGetInfoType_CLI_CURSOR_SENSITIVITY"
	case TGetInfoType_CLI_DESCRIBE_PARAMETER:
		return "TGetInfoType_CLI_DESCRIBE_PARAMETER"
	case TGetInfoType_CLI_CATALOG_NAME:
		return "TGetInfoType_CLI_CATALOG_NAME"
	case TGetInfoType_CLI_COLLATION_SEQ:
		return "TGetInfoType_CLI_COLLATION_SEQ"
	case TGetInfoType_CLI_MAX_IDENTIFIER_LEN:
		return "TGetInfoType_CLI_MAX_IDENTIFIER_LEN"
	}
	return "<UNSET>"
}

func TGetInfoTypeFromString(s string) (TGetInfoType, error) {
	switch s {
	case "TGetInfoType_CLI_MAX_DRIVER_CONNECTIONS":
		return TGetInfoType_CLI_MAX_DRIVER_CONNECTIONS, nil
	case "TGetInfoType_CLI_MAX_CONCURRENT_ACTIVITIES":
		return TGetInfoType_CLI_MAX_CONCURRENT_ACTIVITIES, nil
	case "TGetInfoType_CLI_DATA_SOURCE_NAME":
		return TGetInfoType_CLI_DATA_SOURCE_NAME, nil
	case "TGetInfoType_CLI_FETCH_DIRECTION":
		return TGetInfoType_CLI_FETCH_DIRECTION, nil
	case "TGetInfoType_CLI_SERVER_NAME":
		return TGetInfoType_CLI_SERVER_NAME, nil
	case "TGetInfoType_CLI_SEARCH_PATTERN_ESCAPE":
		return TGetInfoType_CLI_SEARCH_PATTERN_ESCAPE, nil
	case "TGetInfoType_CLI_DBMS_NAME":
		return TGetInfoType_CLI_DBMS_NAME, nil
	case "TGetInfoType_CLI_DBMS_VER":
		return TGetInfoType_CLI_DBMS_VER, nil
	case "TGetInfoType_CLI_ACCESSIBLE_TABLES":
		return TGetInfoType_CLI_ACCESSIBLE_TABLES, nil
	case "TGetInfoType_CLI_ACCESSIBLE_PROCEDURES":
		return TGetInfoType_CLI_ACCESSIBLE_PROCEDURES, nil
	case "TGetInfoType_CLI_CURSOR_COMMIT_BEHAVIOR":
		return TGetInfoType_CLI_CURSOR_COMMIT_BEHAVIOR, nil
	case "TGetInfoType_CLI_DATA_SOURCE_READ_ONLY":
		return TGetInfoType_CLI_DATA_SOURCE_READ_ONLY, nil
	case "TGetInfoType_CLI_DEFAULT_TXN_ISOLATION":
		return TGetInfoType_CLI_DEFAULT_TXN_ISOLATION, nil
	case "TGetInfoType_CLI_IDENTIFIER_CASE":
		return TGetInfoType_CLI_IDENTIFIER_CASE, nil
	case "TGetInfoType_CLI_IDENTIFIER_QUOTE_CHAR":
		return TGetInfoType_CLI_IDENTIFIER_QUOTE_CHAR, nil
	case "TGetInfoType_CLI_MAX_COLUMN_NAME_LEN":
		return TGetInfoType_CLI_MAX_COLUMN_NAME_LEN, nil
	case "TGetInfoType_CLI_MAX_CURSOR_NAME_LEN":
		return TGetInfoType_CLI_MAX_CURSOR_NAME_LEN, nil
	case "TGetInfoType_CLI_MAX_SCHEMA_NAME_LEN":
		return TGetInfoType_CLI_MAX_SCHEMA_NAME_LEN, nil
	case "TGetInfoType_CLI_MAX_CATALOG_NAME_LEN":
		return TGetInfoType_CLI_MAX_CATALOG_NAME_LEN, nil
	case "TGetInfoType_CLI_MAX_TABLE_NAME_LEN":
		return TGetInfoType_CLI_MAX_TABLE_NAME_LEN, nil
	case "TGetInfoType_CLI_SCROLL_CONCURRENCY":
		return TGetInfoType_CLI_SCROLL_CONCURRENCY, nil
	case "TGetInfoType_CLI_TXN_CAPABLE":
		return TGetInfoType_CLI_TXN_CAPABLE, nil
	case "TGetInfoType_CLI_USER_NAME":
		return TGetInfoType_CLI_USER_NAME, nil
	case "TGetInfoType_CLI_TXN_ISOLATION_OPTION":
		return TGetInfoType_CLI_TXN_ISOLATION_OPTION, nil
	case "TGetInfoType_CLI_INTEGRITY":
		return TGetInfoType_CLI_INTEGRITY, nil
	case "TGetInfoType_CLI_GETDATA_EXTENSIONS":
		return TGetInfoType_CLI_GETDATA_EXTENSIONS, nil
	case "TGetInfoType_CLI_NULL_COLLATION":
		return TGetInfoType_CLI_NULL_COLLATION, nil
	case "TGetInfoType_CLI_ALTER_TABLE":
		return TGetInfoType_CLI_ALTER_TABLE, nil
	case "TGetInfoType_CLI_ORDER_BY_COLUMNS_IN_SELECT":
		return TGetInfoType_CLI_ORDER_BY_COLUMNS_IN_SELECT, nil
	case "TGetInfoType_CLI_SPECIAL_CHARACTERS":
		return TGetInfoType_CLI_SPECIAL_CHARACTERS, nil
	case "TGetInfoType_CLI_MAX_COLUMNS_IN_GROUP_BY":
		return TGetInfoType_CLI_MAX_COLUMNS_IN_GROUP_BY, nil
	case "TGetInfoType_CLI_MAX_COLUMNS_IN_INDEX":
		return TGetInfoType_CLI_MAX_COLUMNS_IN_INDEX, nil
	case "TGetInfoType_CLI_MAX_COLUMNS_IN_ORDER_BY":
		return TGetInfoType_CLI_MAX_COLUMNS_IN_ORDER_BY, nil
	case "TGetInfoType_CLI_MAX_COLUMNS_IN_SELECT":
		return TGetInfoType_CLI_MAX_COLUMNS_IN_SELECT, nil
	case "TGetInfoType_CLI_MAX_COLUMNS_IN_TABLE":
		return TGetInfoType_CLI_MAX_COLUMNS_IN_TABLE, nil
	case "TGetInfoType_CLI_MAX_INDEX_SIZE":
		return TGetInfoType_CLI_MAX_INDEX_SIZE, nil
	case "TGetInfoType_CLI_MAX_ROW_SIZE":
		return TGetInfoType_CLI_MAX_ROW_SIZE, nil
	case "TGetInfoType_CLI_MAX_STATEMENT_LEN":
		return TGetInfoType_CLI_MAX_STATEMENT_LEN, nil
	case "TGetInfoType_CLI_MAX_TABLES_IN_SELECT":
		return TGetInfoType_CLI_MAX_TABLES_IN_SELECT, nil
	case "TGetInfoType_CLI_MAX_USER_NAME_LEN":
		return TGetInfoType_CLI_MAX_USER_NAME_LEN, nil
	case "TGetInfoType_CLI_OJ_CAPABILITIES":
		return TGetInfoType_CLI_OJ_CAPABILITIES, nil
	case "TGetInfoType_CLI_XOPEN_CLI_YEAR":
		return TGetInfoType_CLI_XOPEN_CLI_YEAR, nil
	case "TGetInfoType_CLI_CURSOR_SENSITIVITY":
		return TGetInfoType_CLI_CURSOR_SENSITIVITY, nil
	case "TGetInfoType_CLI_DESCRIBE_PARAMETER":
		return TGetInfoType_CLI_DESCRIBE_PARAMETER, nil
	case "TGetInfoType_CLI_CATALOG_NAME":
		return TGetInfoType_CLI_CATALOG_NAME, nil
	case "TGetInfoType_CLI_COLLATION_SEQ":
		return TGetInfoType_CLI_COLLATION_SEQ, nil
	case "TGetInfoType_CLI_MAX_IDENTIFIER_LEN":
		return TGetInfoType_CLI_MAX_IDENTIFIER_LEN, nil
	}
	return TGetInfoType(0), fmt.Errorf("not a valid TGetInfoType string")
}

func TGetInfoTypePtr(v TGetInfoType) *TGetInfoType { return &v }

type TFetchOrientation int64

const (
	TFetchOrientation_FETCH_NEXT     TFetchOrientation = 0
	TFetchOrientation_FETCH_PRIOR    TFetchOrientation = 1
	TFetchOrientation_FETCH_RELATIVE TFetchOrientation = 2
	TFetchOrientation_FETCH_ABSOLUTE TFetchOrientation = 3
	TFetchOrientation_FETCH_FIRST    TFetchOrientation = 4
	TFetchOrientation_FETCH_LAST     TFetchOrientation = 5
)

func (p TFetchOrientation) String() string {
	switch p {
	case TFetchOrientation_FETCH_NEXT:
		return "TFetchOrientation_FETCH_NEXT"
	case TFetchOrientation_FETCH_PRIOR:
		return "TFetchOrientation_FETCH_PRIOR"
	case TFetchOrientation_FETCH_RELATIVE:
		return "TFetchOrientation_FETCH_RELATIVE"
	case TFetchOrientation_FETCH_ABSOLUTE:
		return "TFetchOrientation_FETCH_ABSOLUTE"
	case TFetchOrientation_FETCH_FIRST:
		return "TFetchOrientation_FETCH_FIRST"
	case TFetchOrientation_FETCH_LAST:
		return "TFetchOrientation_FETCH_LAST"
	}
	return "<UNSET>"
}

func TFetchOrientationFromString(s string) (TFetchOrientation, error) {
	switch s {
	case "TFetchOrientation_FETCH_NEXT":
		return TFetchOrientation_FETCH_NEXT, nil
	case "TFetchOrientation_FETCH_PRIOR":
		return TFetchOrientation_FETCH_PRIOR, nil
	case "TFetchOrientation_FETCH_RELATIVE":
		return TFetchOrientation_FETCH_RELATIVE, nil
	case "TFetchOrientation_FETCH_ABSOLUTE":
		return TFetchOrientation_FETCH_ABSOLUTE, nil
	case "TFetchOrientation_FETCH_FIRST":
		return TFetchOrientation_FETCH_FIRST, nil
	case "TFetchOrientation_FETCH_LAST":
		return TFetchOrientation_FETCH_LAST, nil
	}
	return TFetchOrientation(0), fmt.Errorf("not a valid TFetchOrientation string")
}

func TFetchOrientationPtr(v TFetchOrientation) *TFetchOrientation { return &v }

type TTypeEntryPtr int32

func TTypeEntryPtrPtr(v TTypeEntryPtr) *TTypeEntryPtr { return &v }

type TIdentifier string

func TIdentifierPtr(v TIdentifier) *TIdentifier { return &v }

type TPattern string

func TPatternPtr(v TPattern) *TPattern { return &v }

type TPatternOrIdentifier string

func TPatternOrIdentifierPtr(v TPatternOrIdentifier) *TPatternOrIdentifier { return &v }

type TPrimitiveTypeEntry struct {
	TypeA1 TTypeId `thrift:"type,1,required" json:"type"`
}

func NewTPrimitiveTypeEntry() *TPrimitiveTypeEntry {
	return &TPrimitiveTypeEntry{}
}

func (p *TPrimitiveTypeEntry) GetTypeA1() TTypeId {
	return p.TypeA1
}
func (p *TPrimitiveTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TPrimitiveTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := TTypeId(v)
		p.TypeA1 = temp
	}
	return nil
}

func (p *TPrimitiveTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TPrimitiveTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TPrimitiveTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("type", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:type: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TypeA1)); err != nil {
		return fmt.Errorf("%T.type (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:type: %s", p, err)
	}
	return err
}

func (p *TPrimitiveTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TPrimitiveTypeEntry(%+v)", *p)
}

type TArrayTypeEntry struct {
	ObjectTypePtr TTypeEntryPtr `thrift:"objectTypePtr,1,required" json:"objectTypePtr"`
}

func NewTArrayTypeEntry() *TArrayTypeEntry {
	return &TArrayTypeEntry{}
}

func (p *TArrayTypeEntry) GetObjectTypePtr() TTypeEntryPtr {
	return p.ObjectTypePtr
}
func (p *TArrayTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TArrayTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := TTypeEntryPtr(v)
		p.ObjectTypePtr = temp
	}
	return nil
}

func (p *TArrayTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TArrayTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TArrayTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("objectTypePtr", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:objectTypePtr: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.ObjectTypePtr)); err != nil {
		return fmt.Errorf("%T.objectTypePtr (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:objectTypePtr: %s", p, err)
	}
	return err
}

func (p *TArrayTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TArrayTypeEntry(%+v)", *p)
}

type TMapTypeEntry struct {
	KeyTypePtr   TTypeEntryPtr `thrift:"keyTypePtr,1,required" json:"keyTypePtr"`
	ValueTypePtr TTypeEntryPtr `thrift:"valueTypePtr,2,required" json:"valueTypePtr"`
}

func NewTMapTypeEntry() *TMapTypeEntry {
	return &TMapTypeEntry{}
}

func (p *TMapTypeEntry) GetKeyTypePtr() TTypeEntryPtr {
	return p.KeyTypePtr
}

func (p *TMapTypeEntry) GetValueTypePtr() TTypeEntryPtr {
	return p.ValueTypePtr
}
func (p *TMapTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TMapTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := TTypeEntryPtr(v)
		p.KeyTypePtr = temp
	}
	return nil
}

func (p *TMapTypeEntry) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TTypeEntryPtr(v)
		p.ValueTypePtr = temp
	}
	return nil
}

func (p *TMapTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TMapTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TMapTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("keyTypePtr", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:keyTypePtr: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.KeyTypePtr)); err != nil {
		return fmt.Errorf("%T.keyTypePtr (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:keyTypePtr: %s", p, err)
	}
	return err
}

func (p *TMapTypeEntry) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("valueTypePtr", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:valueTypePtr: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.ValueTypePtr)); err != nil {
		return fmt.Errorf("%T.valueTypePtr (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:valueTypePtr: %s", p, err)
	}
	return err
}

func (p *TMapTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TMapTypeEntry(%+v)", *p)
}

type TStructTypeEntry struct {
	NameToTypePtr map[string]TTypeEntryPtr `thrift:"nameToTypePtr,1,required" json:"nameToTypePtr"`
}

func NewTStructTypeEntry() *TStructTypeEntry {
	return &TStructTypeEntry{}
}

func (p *TStructTypeEntry) GetNameToTypePtr() map[string]TTypeEntryPtr {
	return p.NameToTypePtr
}
func (p *TStructTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TStructTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return fmt.Errorf("error reading map begin: %s", err)
	}
	tMap := make(map[string]TTypeEntryPtr, size)
	p.NameToTypePtr = tMap
	for i := 0; i < size; i++ {
		var _key0 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_key0 = v
		}
		var _val1 TTypeEntryPtr
		if v, err := iprot.ReadI32(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			temp := TTypeEntryPtr(v)
			_val1 = temp
		}
		p.NameToTypePtr[_key0] = _val1
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return fmt.Errorf("error reading map end: %s", err)
	}
	return nil
}

func (p *TStructTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TStructTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TStructTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("nameToTypePtr", thrift.MAP, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:nameToTypePtr: %s", p, err)
	}
	if err := oprot.WriteMapBegin(thrift.STRING, thrift.I32, len(p.NameToTypePtr)); err != nil {
		return fmt.Errorf("error writing map begin: %s", err)
	}
	for k, v := range p.NameToTypePtr {
		if err := oprot.WriteString(string(k)); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
		if err := oprot.WriteI32(int32(v)); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
	}
	if err := oprot.WriteMapEnd(); err != nil {
		return fmt.Errorf("error writing map end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:nameToTypePtr: %s", p, err)
	}
	return err
}

func (p *TStructTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TStructTypeEntry(%+v)", *p)
}

type TUnionTypeEntry struct {
	NameToTypePtr map[string]TTypeEntryPtr `thrift:"nameToTypePtr,1,required" json:"nameToTypePtr"`
}

func NewTUnionTypeEntry() *TUnionTypeEntry {
	return &TUnionTypeEntry{}
}

func (p *TUnionTypeEntry) GetNameToTypePtr() map[string]TTypeEntryPtr {
	return p.NameToTypePtr
}
func (p *TUnionTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TUnionTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return fmt.Errorf("error reading map begin: %s", err)
	}
	tMap := make(map[string]TTypeEntryPtr, size)
	p.NameToTypePtr = tMap
	for i := 0; i < size; i++ {
		var _key2 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_key2 = v
		}
		var _val3 TTypeEntryPtr
		if v, err := iprot.ReadI32(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			temp := TTypeEntryPtr(v)
			_val3 = temp
		}
		p.NameToTypePtr[_key2] = _val3
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return fmt.Errorf("error reading map end: %s", err)
	}
	return nil
}

func (p *TUnionTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TUnionTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TUnionTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("nameToTypePtr", thrift.MAP, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:nameToTypePtr: %s", p, err)
	}
	if err := oprot.WriteMapBegin(thrift.STRING, thrift.I32, len(p.NameToTypePtr)); err != nil {
		return fmt.Errorf("error writing map begin: %s", err)
	}
	for k, v := range p.NameToTypePtr {
		if err := oprot.WriteString(string(k)); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
		if err := oprot.WriteI32(int32(v)); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
	}
	if err := oprot.WriteMapEnd(); err != nil {
		return fmt.Errorf("error writing map end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:nameToTypePtr: %s", p, err)
	}
	return err
}

func (p *TUnionTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TUnionTypeEntry(%+v)", *p)
}

type TUserDefinedTypeEntry struct {
	TypeClassName string `thrift:"typeClassName,1,required" json:"typeClassName"`
}

func NewTUserDefinedTypeEntry() *TUserDefinedTypeEntry {
	return &TUserDefinedTypeEntry{}
}

func (p *TUserDefinedTypeEntry) GetTypeClassName() string {
	return p.TypeClassName
}
func (p *TUserDefinedTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TUserDefinedTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.TypeClassName = v
	}
	return nil
}

func (p *TUserDefinedTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TUserDefinedTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TUserDefinedTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("typeClassName", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:typeClassName: %s", p, err)
	}
	if err := oprot.WriteString(string(p.TypeClassName)); err != nil {
		return fmt.Errorf("%T.typeClassName (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:typeClassName: %s", p, err)
	}
	return err
}

func (p *TUserDefinedTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TUserDefinedTypeEntry(%+v)", *p)
}

type TTypeEntry struct {
	PrimitiveEntry       *TPrimitiveTypeEntry   `thrift:"primitiveEntry,1" json:"primitiveEntry"`
	ArrayEntry           *TArrayTypeEntry       `thrift:"arrayEntry,2" json:"arrayEntry"`
	MapEntry             *TMapTypeEntry         `thrift:"mapEntry,3" json:"mapEntry"`
	StructEntry          *TStructTypeEntry      `thrift:"structEntry,4" json:"structEntry"`
	UnionEntry           *TUnionTypeEntry       `thrift:"unionEntry,5" json:"unionEntry"`
	UserDefinedTypeEntry *TUserDefinedTypeEntry `thrift:"userDefinedTypeEntry,6" json:"userDefinedTypeEntry"`
}

func NewTTypeEntry() *TTypeEntry {
	return &TTypeEntry{}
}

var TTypeEntry_PrimitiveEntry_DEFAULT *TPrimitiveTypeEntry

func (p *TTypeEntry) GetPrimitiveEntry() *TPrimitiveTypeEntry {
	if !p.IsSetPrimitiveEntry() {
		return TTypeEntry_PrimitiveEntry_DEFAULT
	}
	return p.PrimitiveEntry
}

var TTypeEntry_ArrayEntry_DEFAULT *TArrayTypeEntry

func (p *TTypeEntry) GetArrayEntry() *TArrayTypeEntry {
	if !p.IsSetArrayEntry() {
		return TTypeEntry_ArrayEntry_DEFAULT
	}
	return p.ArrayEntry
}

var TTypeEntry_MapEntry_DEFAULT *TMapTypeEntry

func (p *TTypeEntry) GetMapEntry() *TMapTypeEntry {
	if !p.IsSetMapEntry() {
		return TTypeEntry_MapEntry_DEFAULT
	}
	return p.MapEntry
}

var TTypeEntry_StructEntry_DEFAULT *TStructTypeEntry

func (p *TTypeEntry) GetStructEntry() *TStructTypeEntry {
	if !p.IsSetStructEntry() {
		return TTypeEntry_StructEntry_DEFAULT
	}
	return p.StructEntry
}

var TTypeEntry_UnionEntry_DEFAULT *TUnionTypeEntry

func (p *TTypeEntry) GetUnionEntry() *TUnionTypeEntry {
	if !p.IsSetUnionEntry() {
		return TTypeEntry_UnionEntry_DEFAULT
	}
	return p.UnionEntry
}

var TTypeEntry_UserDefinedTypeEntry_DEFAULT *TUserDefinedTypeEntry

func (p *TTypeEntry) GetUserDefinedTypeEntry() *TUserDefinedTypeEntry {
	if !p.IsSetUserDefinedTypeEntry() {
		return TTypeEntry_UserDefinedTypeEntry_DEFAULT
	}
	return p.UserDefinedTypeEntry
}
func (p *TTypeEntry) IsSetPrimitiveEntry() bool {
	return p.PrimitiveEntry != nil
}

func (p *TTypeEntry) IsSetArrayEntry() bool {
	return p.ArrayEntry != nil
}

func (p *TTypeEntry) IsSetMapEntry() bool {
	return p.MapEntry != nil
}

func (p *TTypeEntry) IsSetStructEntry() bool {
	return p.StructEntry != nil
}

func (p *TTypeEntry) IsSetUnionEntry() bool {
	return p.UnionEntry != nil
}

func (p *TTypeEntry) IsSetUserDefinedTypeEntry() bool {
	return p.UserDefinedTypeEntry != nil
}

func (p *TTypeEntry) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TTypeEntry) ReadField1(iprot thrift.TProtocol) error {
	p.PrimitiveEntry = &TPrimitiveTypeEntry{}
	if err := p.PrimitiveEntry.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.PrimitiveEntry, err)
	}
	return nil
}

func (p *TTypeEntry) ReadField2(iprot thrift.TProtocol) error {
	p.ArrayEntry = &TArrayTypeEntry{}
	if err := p.ArrayEntry.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ArrayEntry, err)
	}
	return nil
}

func (p *TTypeEntry) ReadField3(iprot thrift.TProtocol) error {
	p.MapEntry = &TMapTypeEntry{}
	if err := p.MapEntry.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.MapEntry, err)
	}
	return nil
}

func (p *TTypeEntry) ReadField4(iprot thrift.TProtocol) error {
	p.StructEntry = &TStructTypeEntry{}
	if err := p.StructEntry.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.StructEntry, err)
	}
	return nil
}

func (p *TTypeEntry) ReadField5(iprot thrift.TProtocol) error {
	p.UnionEntry = &TUnionTypeEntry{}
	if err := p.UnionEntry.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.UnionEntry, err)
	}
	return nil
}

func (p *TTypeEntry) ReadField6(iprot thrift.TProtocol) error {
	p.UserDefinedTypeEntry = &TUserDefinedTypeEntry{}
	if err := p.UserDefinedTypeEntry.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.UserDefinedTypeEntry, err)
	}
	return nil
}

func (p *TTypeEntry) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TTypeEntry"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TTypeEntry) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("primitiveEntry", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:primitiveEntry: %s", p, err)
	}
	if err := p.PrimitiveEntry.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.PrimitiveEntry, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:primitiveEntry: %s", p, err)
	}
	return err
}

func (p *TTypeEntry) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("arrayEntry", thrift.STRUCT, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:arrayEntry: %s", p, err)
	}
	if err := p.ArrayEntry.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.ArrayEntry, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:arrayEntry: %s", p, err)
	}
	return err
}

func (p *TTypeEntry) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("mapEntry", thrift.STRUCT, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:mapEntry: %s", p, err)
	}
	if err := p.MapEntry.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.MapEntry, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:mapEntry: %s", p, err)
	}
	return err
}

func (p *TTypeEntry) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("structEntry", thrift.STRUCT, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:structEntry: %s", p, err)
	}
	if err := p.StructEntry.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.StructEntry, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:structEntry: %s", p, err)
	}
	return err
}

func (p *TTypeEntry) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("unionEntry", thrift.STRUCT, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:unionEntry: %s", p, err)
	}
	if err := p.UnionEntry.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.UnionEntry, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:unionEntry: %s", p, err)
	}
	return err
}

func (p *TTypeEntry) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userDefinedTypeEntry", thrift.STRUCT, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:userDefinedTypeEntry: %s", p, err)
	}
	if err := p.UserDefinedTypeEntry.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.UserDefinedTypeEntry, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:userDefinedTypeEntry: %s", p, err)
	}
	return err
}

func (p *TTypeEntry) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TTypeEntry(%+v)", *p)
}

type TTypeDesc struct {
	Types []*TTypeEntry `thrift:"types,1,required" json:"types"`
}

func NewTTypeDesc() *TTypeDesc {
	return &TTypeDesc{}
}

func (p *TTypeDesc) GetTypes() []*TTypeEntry {
	return p.Types
}
func (p *TTypeDesc) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TTypeDesc) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TTypeEntry, 0, size)
	p.Types = tSlice
	for i := 0; i < size; i++ {
		_elem4 := &TTypeEntry{}
		if err := _elem4.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem4, err)
		}
		p.Types = append(p.Types, _elem4)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TTypeDesc) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TTypeDesc"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TTypeDesc) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("types", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:types: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Types)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.Types {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:types: %s", p, err)
	}
	return err
}

func (p *TTypeDesc) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TTypeDesc(%+v)", *p)
}

type TColumnDesc struct {
	ColumnName string     `thrift:"columnName,1,required" json:"columnName"`
	TypeDesc   *TTypeDesc `thrift:"typeDesc,2,required" json:"typeDesc"`
	Position   int32      `thrift:"position,3,required" json:"position"`
	Comment    *string    `thrift:"comment,4" json:"comment"`
}

func NewTColumnDesc() *TColumnDesc {
	return &TColumnDesc{}
}

func (p *TColumnDesc) GetColumnName() string {
	return p.ColumnName
}

var TColumnDesc_TypeDesc_DEFAULT *TTypeDesc

func (p *TColumnDesc) GetTypeDesc() *TTypeDesc {
	if !p.IsSetTypeDesc() {
		return TColumnDesc_TypeDesc_DEFAULT
	}
	return p.TypeDesc
}

func (p *TColumnDesc) GetPosition() int32 {
	return p.Position
}

var TColumnDesc_Comment_DEFAULT string

func (p *TColumnDesc) GetComment() string {
	if !p.IsSetComment() {
		return TColumnDesc_Comment_DEFAULT
	}
	return *p.Comment
}
func (p *TColumnDesc) IsSetTypeDesc() bool {
	return p.TypeDesc != nil
}

func (p *TColumnDesc) IsSetComment() bool {
	return p.Comment != nil
}

func (p *TColumnDesc) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TColumnDesc) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.ColumnName = v
	}
	return nil
}

func (p *TColumnDesc) ReadField2(iprot thrift.TProtocol) error {
	p.TypeDesc = &TTypeDesc{}
	if err := p.TypeDesc.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.TypeDesc, err)
	}
	return nil
}

func (p *TColumnDesc) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Position = v
	}
	return nil
}

func (p *TColumnDesc) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.Comment = &v
	}
	return nil
}

func (p *TColumnDesc) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TColumnDesc"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TColumnDesc) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("columnName", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:columnName: %s", p, err)
	}
	if err := oprot.WriteString(string(p.ColumnName)); err != nil {
		return fmt.Errorf("%T.columnName (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:columnName: %s", p, err)
	}
	return err
}

func (p *TColumnDesc) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("typeDesc", thrift.STRUCT, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:typeDesc: %s", p, err)
	}
	if err := p.TypeDesc.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.TypeDesc, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:typeDesc: %s", p, err)
	}
	return err
}

func (p *TColumnDesc) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("position", thrift.I32, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:position: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Position)); err != nil {
		return fmt.Errorf("%T.position (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:position: %s", p, err)
	}
	return err
}

func (p *TColumnDesc) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetComment() {
		if err := oprot.WriteFieldBegin("comment", thrift.STRING, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:comment: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Comment)); err != nil {
			return fmt.Errorf("%T.comment (4) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:comment: %s", p, err)
		}
	}
	return err
}

func (p *TColumnDesc) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TColumnDesc(%+v)", *p)
}

type TTableSchema struct {
	Columns []*TColumnDesc `thrift:"columns,1,required" json:"columns"`
}

func NewTTableSchema() *TTableSchema {
	return &TTableSchema{}
}

func (p *TTableSchema) GetColumns() []*TColumnDesc {
	return p.Columns
}
func (p *TTableSchema) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TTableSchema) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TColumnDesc, 0, size)
	p.Columns = tSlice
	for i := 0; i < size; i++ {
		_elem5 := &TColumnDesc{}
		if err := _elem5.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem5, err)
		}
		p.Columns = append(p.Columns, _elem5)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TTableSchema) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TTableSchema"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TTableSchema) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("columns", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:columns: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Columns)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.Columns {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:columns: %s", p, err)
	}
	return err
}

func (p *TTableSchema) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TTableSchema(%+v)", *p)
}

type TBoolValue struct {
	Value *bool `thrift:"value,1" json:"value"`
}

func NewTBoolValue() *TBoolValue {
	return &TBoolValue{}
}

var TBoolValue_Value_DEFAULT bool

func (p *TBoolValue) GetValue() bool {
	if !p.IsSetValue() {
		return TBoolValue_Value_DEFAULT
	}
	return *p.Value
}
func (p *TBoolValue) IsSetValue() bool {
	return p.Value != nil
}

func (p *TBoolValue) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TBoolValue) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Value = &v
	}
	return nil
}

func (p *TBoolValue) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TBoolValue"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TBoolValue) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.BOOL, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteBool(bool(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TBoolValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TBoolValue(%+v)", *p)
}

type TByteValue struct {
	Value *int8 `thrift:"value,1" json:"value"`
}

func NewTByteValue() *TByteValue {
	return &TByteValue{}
}

var TByteValue_Value_DEFAULT int8

func (p *TByteValue) GetValue() int8 {
	if !p.IsSetValue() {
		return TByteValue_Value_DEFAULT
	}
	return *p.Value
}
func (p *TByteValue) IsSetValue() bool {
	return p.Value != nil
}

func (p *TByteValue) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TByteValue) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := int8(v)
		p.Value = &temp
	}
	return nil
}

func (p *TByteValue) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TByteValue"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TByteValue) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.BYTE, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteByte(byte(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TByteValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TByteValue(%+v)", *p)
}

type TI16Value struct {
	Value *int16 `thrift:"value,1" json:"value"`
}

func NewTI16Value() *TI16Value {
	return &TI16Value{}
}

var TI16Value_Value_DEFAULT int16

func (p *TI16Value) GetValue() int16 {
	if !p.IsSetValue() {
		return TI16Value_Value_DEFAULT
	}
	return *p.Value
}
func (p *TI16Value) IsSetValue() bool {
	return p.Value != nil
}

func (p *TI16Value) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TI16Value) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Value = &v
	}
	return nil
}

func (p *TI16Value) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TI16Value"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TI16Value) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.I16, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteI16(int16(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TI16Value) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TI16Value(%+v)", *p)
}

type TI32Value struct {
	Value *int32 `thrift:"value,1" json:"value"`
}

func NewTI32Value() *TI32Value {
	return &TI32Value{}
}

var TI32Value_Value_DEFAULT int32

func (p *TI32Value) GetValue() int32 {
	if !p.IsSetValue() {
		return TI32Value_Value_DEFAULT
	}
	return *p.Value
}
func (p *TI32Value) IsSetValue() bool {
	return p.Value != nil
}

func (p *TI32Value) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TI32Value) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Value = &v
	}
	return nil
}

func (p *TI32Value) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TI32Value"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TI32Value) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.I32, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteI32(int32(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TI32Value) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TI32Value(%+v)", *p)
}

type TI64Value struct {
	Value *int64 `thrift:"value,1" json:"value"`
}

func NewTI64Value() *TI64Value {
	return &TI64Value{}
}

var TI64Value_Value_DEFAULT int64

func (p *TI64Value) GetValue() int64 {
	if !p.IsSetValue() {
		return TI64Value_Value_DEFAULT
	}
	return *p.Value
}
func (p *TI64Value) IsSetValue() bool {
	return p.Value != nil
}

func (p *TI64Value) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TI64Value) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Value = &v
	}
	return nil
}

func (p *TI64Value) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TI64Value"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TI64Value) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.I64, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteI64(int64(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TI64Value) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TI64Value(%+v)", *p)
}

type TDoubleValue struct {
	Value *float64 `thrift:"value,1" json:"value"`
}

func NewTDoubleValue() *TDoubleValue {
	return &TDoubleValue{}
}

var TDoubleValue_Value_DEFAULT float64

func (p *TDoubleValue) GetValue() float64 {
	if !p.IsSetValue() {
		return TDoubleValue_Value_DEFAULT
	}
	return *p.Value
}
func (p *TDoubleValue) IsSetValue() bool {
	return p.Value != nil
}

func (p *TDoubleValue) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TDoubleValue) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Value = &v
	}
	return nil
}

func (p *TDoubleValue) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TDoubleValue"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TDoubleValue) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.DOUBLE, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteDouble(float64(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TDoubleValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TDoubleValue(%+v)", *p)
}

type TStringValue struct {
	Value *string `thrift:"value,1" json:"value"`
}

func NewTStringValue() *TStringValue {
	return &TStringValue{}
}

var TStringValue_Value_DEFAULT string

func (p *TStringValue) GetValue() string {
	if !p.IsSetValue() {
		return TStringValue_Value_DEFAULT
	}
	return *p.Value
}
func (p *TStringValue) IsSetValue() bool {
	return p.Value != nil
}

func (p *TStringValue) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TStringValue) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Value = &v
	}
	return nil
}

func (p *TStringValue) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TStringValue"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TStringValue) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetValue() {
		if err := oprot.WriteFieldBegin("value", thrift.STRING, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Value)); err != nil {
			return fmt.Errorf("%T.value (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:value: %s", p, err)
		}
	}
	return err
}

func (p *TStringValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TStringValue(%+v)", *p)
}

type TColumn struct {
	BoolColumn   []*TBoolValue   `thrift:"boolColumn,1" json:"boolColumn"`
	ByteColumn   []*TByteValue   `thrift:"byteColumn,2" json:"byteColumn"`
	I16Column    []*TI16Value    `thrift:"i16Column,3" json:"i16Column"`
	I32Column    []*TI32Value    `thrift:"i32Column,4" json:"i32Column"`
	I64Column    []*TI64Value    `thrift:"i64Column,5" json:"i64Column"`
	DoubleColumn []*TDoubleValue `thrift:"doubleColumn,6" json:"doubleColumn"`
	StringColumn []*TStringValue `thrift:"stringColumn,7" json:"stringColumn"`
}

func NewTColumn() *TColumn {
	return &TColumn{}
}

func (p *TColumn) GetBoolColumn() []*TBoolValue {
	return p.BoolColumn
}

func (p *TColumn) GetByteColumn() []*TByteValue {
	return p.ByteColumn
}

func (p *TColumn) GetI16Column() []*TI16Value {
	return p.I16Column
}

func (p *TColumn) GetI32Column() []*TI32Value {
	return p.I32Column
}

func (p *TColumn) GetI64Column() []*TI64Value {
	return p.I64Column
}

func (p *TColumn) GetDoubleColumn() []*TDoubleValue {
	return p.DoubleColumn
}

func (p *TColumn) GetStringColumn() []*TStringValue {
	return p.StringColumn
}
func (p *TColumn) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TColumn) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TBoolValue, 0, size)
	p.BoolColumn = tSlice
	for i := 0; i < size; i++ {
		_elem6 := &TBoolValue{}
		if err := _elem6.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem6, err)
		}
		p.BoolColumn = append(p.BoolColumn, _elem6)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TByteValue, 0, size)
	p.ByteColumn = tSlice
	for i := 0; i < size; i++ {
		_elem7 := &TByteValue{}
		if err := _elem7.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem7, err)
		}
		p.ByteColumn = append(p.ByteColumn, _elem7)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TI16Value, 0, size)
	p.I16Column = tSlice
	for i := 0; i < size; i++ {
		_elem8 := &TI16Value{}
		if err := _elem8.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem8, err)
		}
		p.I16Column = append(p.I16Column, _elem8)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) ReadField4(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TI32Value, 0, size)
	p.I32Column = tSlice
	for i := 0; i < size; i++ {
		_elem9 := &TI32Value{}
		if err := _elem9.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem9, err)
		}
		p.I32Column = append(p.I32Column, _elem9)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) ReadField5(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TI64Value, 0, size)
	p.I64Column = tSlice
	for i := 0; i < size; i++ {
		_elem10 := &TI64Value{}
		if err := _elem10.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem10, err)
		}
		p.I64Column = append(p.I64Column, _elem10)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) ReadField6(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TDoubleValue, 0, size)
	p.DoubleColumn = tSlice
	for i := 0; i < size; i++ {
		_elem11 := &TDoubleValue{}
		if err := _elem11.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem11, err)
		}
		p.DoubleColumn = append(p.DoubleColumn, _elem11)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) ReadField7(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TStringValue, 0, size)
	p.StringColumn = tSlice
	for i := 0; i < size; i++ {
		_elem12 := &TStringValue{}
		if err := _elem12.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem12, err)
		}
		p.StringColumn = append(p.StringColumn, _elem12)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TColumn) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TColumn"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TColumn) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("boolColumn", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:boolColumn: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.BoolColumn)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.BoolColumn {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:boolColumn: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("byteColumn", thrift.LIST, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:byteColumn: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.ByteColumn)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.ByteColumn {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:byteColumn: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("i16Column", thrift.LIST, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:i16Column: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.I16Column)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.I16Column {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:i16Column: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("i32Column", thrift.LIST, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:i32Column: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.I32Column)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.I32Column {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:i32Column: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("i64Column", thrift.LIST, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:i64Column: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.I64Column)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.I64Column {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:i64Column: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("doubleColumn", thrift.LIST, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:doubleColumn: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.DoubleColumn)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.DoubleColumn {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:doubleColumn: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("stringColumn", thrift.LIST, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:stringColumn: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.StringColumn)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.StringColumn {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:stringColumn: %s", p, err)
	}
	return err
}

func (p *TColumn) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TColumn(%+v)", *p)
}

type TColumnValue struct {
	BoolVal   *TBoolValue   `thrift:"boolVal,1" json:"boolVal"`
	ByteVal   *TByteValue   `thrift:"byteVal,2" json:"byteVal"`
	I16Val    *TI16Value    `thrift:"i16Val,3" json:"i16Val"`
	I32Val    *TI32Value    `thrift:"i32Val,4" json:"i32Val"`
	I64Val    *TI64Value    `thrift:"i64Val,5" json:"i64Val"`
	DoubleVal *TDoubleValue `thrift:"doubleVal,6" json:"doubleVal"`
	StringVal *TStringValue `thrift:"stringVal,7" json:"stringVal"`
}

func NewTColumnValue() *TColumnValue {
	return &TColumnValue{}
}

var TColumnValue_BoolVal_DEFAULT *TBoolValue

func (p *TColumnValue) GetBoolVal() *TBoolValue {
	if !p.IsSetBoolVal() {
		return TColumnValue_BoolVal_DEFAULT
	}
	return p.BoolVal
}

var TColumnValue_ByteVal_DEFAULT *TByteValue

func (p *TColumnValue) GetByteVal() *TByteValue {
	if !p.IsSetByteVal() {
		return TColumnValue_ByteVal_DEFAULT
	}
	return p.ByteVal
}

var TColumnValue_I16Val_DEFAULT *TI16Value

func (p *TColumnValue) GetI16Val() *TI16Value {
	if !p.IsSetI16Val() {
		return TColumnValue_I16Val_DEFAULT
	}
	return p.I16Val
}

var TColumnValue_I32Val_DEFAULT *TI32Value

func (p *TColumnValue) GetI32Val() *TI32Value {
	if !p.IsSetI32Val() {
		return TColumnValue_I32Val_DEFAULT
	}
	return p.I32Val
}

var TColumnValue_I64Val_DEFAULT *TI64Value

func (p *TColumnValue) GetI64Val() *TI64Value {
	if !p.IsSetI64Val() {
		return TColumnValue_I64Val_DEFAULT
	}
	return p.I64Val
}

var TColumnValue_DoubleVal_DEFAULT *TDoubleValue

func (p *TColumnValue) GetDoubleVal() *TDoubleValue {
	if !p.IsSetDoubleVal() {
		return TColumnValue_DoubleVal_DEFAULT
	}
	return p.DoubleVal
}

var TColumnValue_StringVal_DEFAULT *TStringValue

func (p *TColumnValue) GetStringVal() *TStringValue {
	if !p.IsSetStringVal() {
		return TColumnValue_StringVal_DEFAULT
	}
	return p.StringVal
}
func (p *TColumnValue) IsSetBoolVal() bool {
	return p.BoolVal != nil
}

func (p *TColumnValue) IsSetByteVal() bool {
	return p.ByteVal != nil
}

func (p *TColumnValue) IsSetI16Val() bool {
	return p.I16Val != nil
}

func (p *TColumnValue) IsSetI32Val() bool {
	return p.I32Val != nil
}

func (p *TColumnValue) IsSetI64Val() bool {
	return p.I64Val != nil
}

func (p *TColumnValue) IsSetDoubleVal() bool {
	return p.DoubleVal != nil
}

func (p *TColumnValue) IsSetStringVal() bool {
	return p.StringVal != nil
}

func (p *TColumnValue) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TColumnValue) ReadField1(iprot thrift.TProtocol) error {
	p.BoolVal = &TBoolValue{}
	if err := p.BoolVal.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.BoolVal, err)
	}
	return nil
}

func (p *TColumnValue) ReadField2(iprot thrift.TProtocol) error {
	p.ByteVal = &TByteValue{}
	if err := p.ByteVal.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ByteVal, err)
	}
	return nil
}

func (p *TColumnValue) ReadField3(iprot thrift.TProtocol) error {
	p.I16Val = &TI16Value{}
	if err := p.I16Val.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.I16Val, err)
	}
	return nil
}

func (p *TColumnValue) ReadField4(iprot thrift.TProtocol) error {
	p.I32Val = &TI32Value{}
	if err := p.I32Val.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.I32Val, err)
	}
	return nil
}

func (p *TColumnValue) ReadField5(iprot thrift.TProtocol) error {
	p.I64Val = &TI64Value{}
	if err := p.I64Val.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.I64Val, err)
	}
	return nil
}

func (p *TColumnValue) ReadField6(iprot thrift.TProtocol) error {
	p.DoubleVal = &TDoubleValue{}
	if err := p.DoubleVal.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.DoubleVal, err)
	}
	return nil
}

func (p *TColumnValue) ReadField7(iprot thrift.TProtocol) error {
	p.StringVal = &TStringValue{}
	if err := p.StringVal.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.StringVal, err)
	}
	return nil
}

func (p *TColumnValue) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TColumnValue"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TColumnValue) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("boolVal", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:boolVal: %s", p, err)
	}
	if err := p.BoolVal.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.BoolVal, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:boolVal: %s", p, err)
	}
	return err
}

func (p *TColumnValue) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("byteVal", thrift.STRUCT, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:byteVal: %s", p, err)
	}
	if err := p.ByteVal.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.ByteVal, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:byteVal: %s", p, err)
	}
	return err
}

func (p *TColumnValue) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("i16Val", thrift.STRUCT, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:i16Val: %s", p, err)
	}
	if err := p.I16Val.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.I16Val, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:i16Val: %s", p, err)
	}
	return err
}

func (p *TColumnValue) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("i32Val", thrift.STRUCT, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:i32Val: %s", p, err)
	}
	if err := p.I32Val.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.I32Val, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:i32Val: %s", p, err)
	}
	return err
}

func (p *TColumnValue) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("i64Val", thrift.STRUCT, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:i64Val: %s", p, err)
	}
	if err := p.I64Val.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.I64Val, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:i64Val: %s", p, err)
	}
	return err
}

func (p *TColumnValue) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("doubleVal", thrift.STRUCT, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:doubleVal: %s", p, err)
	}
	if err := p.DoubleVal.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.DoubleVal, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:doubleVal: %s", p, err)
	}
	return err
}

func (p *TColumnValue) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("stringVal", thrift.STRUCT, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:stringVal: %s", p, err)
	}
	if err := p.StringVal.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.StringVal, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:stringVal: %s", p, err)
	}
	return err
}

func (p *TColumnValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TColumnValue(%+v)", *p)
}

type TRow struct {
	ColVals []*TColumnValue `thrift:"colVals,1,required" json:"colVals"`
}

func NewTRow() *TRow {
	return &TRow{}
}

func (p *TRow) GetColVals() []*TColumnValue {
	return p.ColVals
}
func (p *TRow) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TRow) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TColumnValue, 0, size)
	p.ColVals = tSlice
	for i := 0; i < size; i++ {
		_elem13 := &TColumnValue{}
		if err := _elem13.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem13, err)
		}
		p.ColVals = append(p.ColVals, _elem13)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TRow) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TRow"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TRow) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("colVals", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:colVals: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.ColVals)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.ColVals {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:colVals: %s", p, err)
	}
	return err
}

func (p *TRow) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TRow(%+v)", *p)
}

type TRowSet struct {
	StartRowOffset int64      `thrift:"startRowOffset,1,required" json:"startRowOffset"`
	Rows           []*TRow    `thrift:"rows,2,required" json:"rows"`
	Columns        []*TColumn `thrift:"columns,3" json:"columns"`
}

func NewTRowSet() *TRowSet {
	return &TRowSet{}
}

func (p *TRowSet) GetStartRowOffset() int64 {
	return p.StartRowOffset
}

func (p *TRowSet) GetRows() []*TRow {
	return p.Rows
}

var TRowSet_Columns_DEFAULT []*TColumn

func (p *TRowSet) GetColumns() []*TColumn {
	return p.Columns
}
func (p *TRowSet) IsSetColumns() bool {
	return p.Columns != nil
}

func (p *TRowSet) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TRowSet) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.StartRowOffset = v
	}
	return nil
}

func (p *TRowSet) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TRow, 0, size)
	p.Rows = tSlice
	for i := 0; i < size; i++ {
		_elem14 := &TRow{}
		if err := _elem14.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem14, err)
		}
		p.Rows = append(p.Rows, _elem14)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TRowSet) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TColumn, 0, size)
	p.Columns = tSlice
	for i := 0; i < size; i++ {
		_elem15 := &TColumn{}
		if err := _elem15.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem15, err)
		}
		p.Columns = append(p.Columns, _elem15)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TRowSet) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TRowSet"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TRowSet) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("startRowOffset", thrift.I64, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:startRowOffset: %s", p, err)
	}
	if err := oprot.WriteI64(int64(p.StartRowOffset)); err != nil {
		return fmt.Errorf("%T.startRowOffset (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:startRowOffset: %s", p, err)
	}
	return err
}

func (p *TRowSet) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("rows", thrift.LIST, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:rows: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Rows)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.Rows {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:rows: %s", p, err)
	}
	return err
}

func (p *TRowSet) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetColumns() {
		if err := oprot.WriteFieldBegin("columns", thrift.LIST, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:columns: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Columns)); err != nil {
			return fmt.Errorf("error writing list begin: %s", err)
		}
		for _, v := range p.Columns {
			if err := v.Write(oprot); err != nil {
				return fmt.Errorf("%T error writing struct: %s", v, err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:columns: %s", p, err)
		}
	}
	return err
}

func (p *TRowSet) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TRowSet(%+v)", *p)
}

type TStatus struct {
	StatusCode   TStatusCode `thrift:"statusCode,1,required" json:"statusCode"`
	InfoMessages []string    `thrift:"infoMessages,2" json:"infoMessages"`
	SqlState     *string     `thrift:"sqlState,3" json:"sqlState"`
	ErrorCode    *int32      `thrift:"errorCode,4" json:"errorCode"`
	ErrorMessage *string     `thrift:"errorMessage,5" json:"errorMessage"`
}

func NewTStatus() *TStatus {
	return &TStatus{}
}

func (p *TStatus) GetStatusCode() TStatusCode {
	return p.StatusCode
}

var TStatus_InfoMessages_DEFAULT []string

func (p *TStatus) GetInfoMessages() []string {
	return p.InfoMessages
}

var TStatus_SqlState_DEFAULT string

func (p *TStatus) GetSqlState() string {
	if !p.IsSetSqlState() {
		return TStatus_SqlState_DEFAULT
	}
	return *p.SqlState
}

var TStatus_ErrorCode_DEFAULT int32

func (p *TStatus) GetErrorCode() int32 {
	if !p.IsSetErrorCode() {
		return TStatus_ErrorCode_DEFAULT
	}
	return *p.ErrorCode
}

var TStatus_ErrorMessage_DEFAULT string

func (p *TStatus) GetErrorMessage() string {
	if !p.IsSetErrorMessage() {
		return TStatus_ErrorMessage_DEFAULT
	}
	return *p.ErrorMessage
}
func (p *TStatus) IsSetInfoMessages() bool {
	return p.InfoMessages != nil
}

func (p *TStatus) IsSetSqlState() bool {
	return p.SqlState != nil
}

func (p *TStatus) IsSetErrorCode() bool {
	return p.ErrorCode != nil
}

func (p *TStatus) IsSetErrorMessage() bool {
	return p.ErrorMessage != nil
}

func (p *TStatus) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TStatus) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := TStatusCode(v)
		p.StatusCode = temp
	}
	return nil
}

func (p *TStatus) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]string, 0, size)
	p.InfoMessages = tSlice
	for i := 0; i < size; i++ {
		var _elem16 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_elem16 = v
		}
		p.InfoMessages = append(p.InfoMessages, _elem16)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TStatus) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.SqlState = &v
	}
	return nil
}

func (p *TStatus) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.ErrorCode = &v
	}
	return nil
}

func (p *TStatus) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.ErrorMessage = &v
	}
	return nil
}

func (p *TStatus) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TStatus"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TStatus) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("statusCode", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:statusCode: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.StatusCode)); err != nil {
		return fmt.Errorf("%T.statusCode (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:statusCode: %s", p, err)
	}
	return err
}

func (p *TStatus) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetInfoMessages() {
		if err := oprot.WriteFieldBegin("infoMessages", thrift.LIST, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:infoMessages: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.InfoMessages)); err != nil {
			return fmt.Errorf("error writing list begin: %s", err)
		}
		for _, v := range p.InfoMessages {
			if err := oprot.WriteString(string(v)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:infoMessages: %s", p, err)
		}
	}
	return err
}

func (p *TStatus) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSqlState() {
		if err := oprot.WriteFieldBegin("sqlState", thrift.STRING, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:sqlState: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.SqlState)); err != nil {
			return fmt.Errorf("%T.sqlState (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:sqlState: %s", p, err)
		}
	}
	return err
}

func (p *TStatus) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorCode() {
		if err := oprot.WriteFieldBegin("errorCode", thrift.I32, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:errorCode: %s", p, err)
		}
		if err := oprot.WriteI32(int32(*p.ErrorCode)); err != nil {
			return fmt.Errorf("%T.errorCode (4) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:errorCode: %s", p, err)
		}
	}
	return err
}

func (p *TStatus) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorMessage() {
		if err := oprot.WriteFieldBegin("errorMessage", thrift.STRING, 5); err != nil {
			return fmt.Errorf("%T write field begin error 5:errorMessage: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.ErrorMessage)); err != nil {
			return fmt.Errorf("%T.errorMessage (5) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 5:errorMessage: %s", p, err)
		}
	}
	return err
}

func (p *TStatus) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TStatus(%+v)", *p)
}

type THandleIdentifier struct {
	Guid   []byte `thrift:"guid,1,required" json:"guid"`
	Secret []byte `thrift:"secret,2,required" json:"secret"`
}

func NewTHandleIdentifier() *THandleIdentifier {
	return &THandleIdentifier{}
}

func (p *THandleIdentifier) GetGuid() []byte {
	return p.Guid
}

func (p *THandleIdentifier) GetSecret() []byte {
	return p.Secret
}
func (p *THandleIdentifier) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *THandleIdentifier) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Guid = v
	}
	return nil
}

func (p *THandleIdentifier) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Secret = v
	}
	return nil
}

func (p *THandleIdentifier) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("THandleIdentifier"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *THandleIdentifier) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("guid", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:guid: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Guid); err != nil {
		return fmt.Errorf("%T.guid (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:guid: %s", p, err)
	}
	return err
}

func (p *THandleIdentifier) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("secret", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:secret: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Secret); err != nil {
		return fmt.Errorf("%T.secret (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:secret: %s", p, err)
	}
	return err
}

func (p *THandleIdentifier) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("THandleIdentifier(%+v)", *p)
}

type TSessionHandle struct {
	SessionId *THandleIdentifier `thrift:"sessionId,1,required" json:"sessionId"`
}

func NewTSessionHandle() *TSessionHandle {
	return &TSessionHandle{}
}

var TSessionHandle_SessionId_DEFAULT *THandleIdentifier

func (p *TSessionHandle) GetSessionId() *THandleIdentifier {
	if !p.IsSetSessionId() {
		return TSessionHandle_SessionId_DEFAULT
	}
	return p.SessionId
}
func (p *TSessionHandle) IsSetSessionId() bool {
	return p.SessionId != nil
}

func (p *TSessionHandle) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TSessionHandle) ReadField1(iprot thrift.TProtocol) error {
	p.SessionId = &THandleIdentifier{}
	if err := p.SessionId.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionId, err)
	}
	return nil
}

func (p *TSessionHandle) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TSessionHandle"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TSessionHandle) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionId", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionId: %s", p, err)
	}
	if err := p.SessionId.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionId, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionId: %s", p, err)
	}
	return err
}

func (p *TSessionHandle) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TSessionHandle(%+v)", *p)
}

type TOperationHandle struct {
	OperationId      *THandleIdentifier `thrift:"operationId,1,required" json:"operationId"`
	OperationType    TOperationType     `thrift:"operationType,2,required" json:"operationType"`
	HasResultSet     bool               `thrift:"hasResultSet,3,required" json:"hasResultSet"`
	ModifiedRowCount *float64           `thrift:"modifiedRowCount,4" json:"modifiedRowCount"`
}

func NewTOperationHandle() *TOperationHandle {
	return &TOperationHandle{}
}

var TOperationHandle_OperationId_DEFAULT *THandleIdentifier

func (p *TOperationHandle) GetOperationId() *THandleIdentifier {
	if !p.IsSetOperationId() {
		return TOperationHandle_OperationId_DEFAULT
	}
	return p.OperationId
}

func (p *TOperationHandle) GetOperationType() TOperationType {
	return p.OperationType
}

func (p *TOperationHandle) GetHasResultSet() bool {
	return p.HasResultSet
}

var TOperationHandle_ModifiedRowCount_DEFAULT float64

func (p *TOperationHandle) GetModifiedRowCount() float64 {
	if !p.IsSetModifiedRowCount() {
		return TOperationHandle_ModifiedRowCount_DEFAULT
	}
	return *p.ModifiedRowCount
}
func (p *TOperationHandle) IsSetOperationId() bool {
	return p.OperationId != nil
}

func (p *TOperationHandle) IsSetModifiedRowCount() bool {
	return p.ModifiedRowCount != nil
}

func (p *TOperationHandle) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TOperationHandle) ReadField1(iprot thrift.TProtocol) error {
	p.OperationId = &THandleIdentifier{}
	if err := p.OperationId.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationId, err)
	}
	return nil
}

func (p *TOperationHandle) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TOperationType(v)
		p.OperationType = temp
	}
	return nil
}

func (p *TOperationHandle) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.HasResultSet = v
	}
	return nil
}

func (p *TOperationHandle) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.ModifiedRowCount = &v
	}
	return nil
}

func (p *TOperationHandle) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TOperationHandle"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TOperationHandle) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationId", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:operationId: %s", p, err)
	}
	if err := p.OperationId.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.OperationId, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:operationId: %s", p, err)
	}
	return err
}

func (p *TOperationHandle) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationType", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:operationType: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.OperationType)); err != nil {
		return fmt.Errorf("%T.operationType (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:operationType: %s", p, err)
	}
	return err
}

func (p *TOperationHandle) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hasResultSet", thrift.BOOL, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:hasResultSet: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.HasResultSet)); err != nil {
		return fmt.Errorf("%T.hasResultSet (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:hasResultSet: %s", p, err)
	}
	return err
}

func (p *TOperationHandle) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetModifiedRowCount() {
		if err := oprot.WriteFieldBegin("modifiedRowCount", thrift.DOUBLE, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:modifiedRowCount: %s", p, err)
		}
		if err := oprot.WriteDouble(float64(*p.ModifiedRowCount)); err != nil {
			return fmt.Errorf("%T.modifiedRowCount (4) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:modifiedRowCount: %s", p, err)
		}
	}
	return err
}

func (p *TOperationHandle) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TOperationHandle(%+v)", *p)
}

type TOpenSessionReq struct {
	ClientProtocol TProtocolVersion  `thrift:"client_protocol,1,required" json:"client_protocol"`
	Username       *string           `thrift:"username,2" json:"username"`
	Password       *string           `thrift:"password,3" json:"password"`
	Configuration  map[string]string `thrift:"configuration,4" json:"configuration"`
}

func NewTOpenSessionReq() *TOpenSessionReq {
	return &TOpenSessionReq{
		ClientProtocol: 0,
	}
}

func (p *TOpenSessionReq) GetClientProtocol() TProtocolVersion {
	return p.ClientProtocol
}

var TOpenSessionReq_Username_DEFAULT string

func (p *TOpenSessionReq) GetUsername() string {
	if !p.IsSetUsername() {
		return TOpenSessionReq_Username_DEFAULT
	}
	return *p.Username
}

var TOpenSessionReq_Password_DEFAULT string

func (p *TOpenSessionReq) GetPassword() string {
	if !p.IsSetPassword() {
		return TOpenSessionReq_Password_DEFAULT
	}
	return *p.Password
}

var TOpenSessionReq_Configuration_DEFAULT map[string]string

func (p *TOpenSessionReq) GetConfiguration() map[string]string {
	return p.Configuration
}
func (p *TOpenSessionReq) IsSetUsername() bool {
	return p.Username != nil
}

func (p *TOpenSessionReq) IsSetPassword() bool {
	return p.Password != nil
}

func (p *TOpenSessionReq) IsSetConfiguration() bool {
	return p.Configuration != nil
}

func (p *TOpenSessionReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TOpenSessionReq) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := TProtocolVersion(v)
		p.ClientProtocol = temp
	}
	return nil
}

func (p *TOpenSessionReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Username = &v
	}
	return nil
}

func (p *TOpenSessionReq) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Password = &v
	}
	return nil
}

func (p *TOpenSessionReq) ReadField4(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return fmt.Errorf("error reading map begin: %s", err)
	}
	tMap := make(map[string]string, size)
	p.Configuration = tMap
	for i := 0; i < size; i++ {
		var _key17 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_key17 = v
		}
		var _val18 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_val18 = v
		}
		p.Configuration[_key17] = _val18
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return fmt.Errorf("error reading map end: %s", err)
	}
	return nil
}

func (p *TOpenSessionReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TOpenSessionReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TOpenSessionReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("client_protocol", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:client_protocol: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.ClientProtocol)); err != nil {
		return fmt.Errorf("%T.client_protocol (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:client_protocol: %s", p, err)
	}
	return err
}

func (p *TOpenSessionReq) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetUsername() {
		if err := oprot.WriteFieldBegin("username", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:username: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Username)); err != nil {
			return fmt.Errorf("%T.username (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:username: %s", p, err)
		}
	}
	return err
}

func (p *TOpenSessionReq) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetPassword() {
		if err := oprot.WriteFieldBegin("password", thrift.STRING, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:password: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.Password)); err != nil {
			return fmt.Errorf("%T.password (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:password: %s", p, err)
		}
	}
	return err
}

func (p *TOpenSessionReq) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetConfiguration() {
		if err := oprot.WriteFieldBegin("configuration", thrift.MAP, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:configuration: %s", p, err)
		}
		if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Configuration)); err != nil {
			return fmt.Errorf("error writing map begin: %s", err)
		}
		for k, v := range p.Configuration {
			if err := oprot.WriteString(string(k)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
			if err := oprot.WriteString(string(v)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteMapEnd(); err != nil {
			return fmt.Errorf("error writing map end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:configuration: %s", p, err)
		}
	}
	return err
}

func (p *TOpenSessionReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TOpenSessionReq(%+v)", *p)
}

type TOpenSessionResp struct {
	Status                *TStatus          `thrift:"status,1,required" json:"status"`
	ServerProtocolVersion TProtocolVersion  `thrift:"serverProtocolVersion,2,required" json:"serverProtocolVersion"`
	SessionHandle         *TSessionHandle   `thrift:"sessionHandle,3" json:"sessionHandle"`
	Configuration         map[string]string `thrift:"configuration,4" json:"configuration"`
}

func NewTOpenSessionResp() *TOpenSessionResp {
	return &TOpenSessionResp{
		ServerProtocolVersion: 0,
	}
}

var TOpenSessionResp_Status_DEFAULT *TStatus

func (p *TOpenSessionResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TOpenSessionResp_Status_DEFAULT
	}
	return p.Status
}

func (p *TOpenSessionResp) GetServerProtocolVersion() TProtocolVersion {
	return p.ServerProtocolVersion
}

var TOpenSessionResp_SessionHandle_DEFAULT *TSessionHandle

func (p *TOpenSessionResp) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TOpenSessionResp_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

var TOpenSessionResp_Configuration_DEFAULT map[string]string

func (p *TOpenSessionResp) GetConfiguration() map[string]string {
	return p.Configuration
}
func (p *TOpenSessionResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TOpenSessionResp) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TOpenSessionResp) IsSetConfiguration() bool {
	return p.Configuration != nil
}

func (p *TOpenSessionResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TOpenSessionResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TOpenSessionResp) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TProtocolVersion(v)
		p.ServerProtocolVersion = temp
	}
	return nil
}

func (p *TOpenSessionResp) ReadField3(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TOpenSessionResp) ReadField4(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return fmt.Errorf("error reading map begin: %s", err)
	}
	tMap := make(map[string]string, size)
	p.Configuration = tMap
	for i := 0; i < size; i++ {
		var _key19 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_key19 = v
		}
		var _val20 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_val20 = v
		}
		p.Configuration[_key19] = _val20
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return fmt.Errorf("error reading map end: %s", err)
	}
	return nil
}

func (p *TOpenSessionResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TOpenSessionResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TOpenSessionResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TOpenSessionResp) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("serverProtocolVersion", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:serverProtocolVersion: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.ServerProtocolVersion)); err != nil {
		return fmt.Errorf("%T.serverProtocolVersion (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:serverProtocolVersion: %s", p, err)
	}
	return err
}

func (p *TOpenSessionResp) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSessionHandle() {
		if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:sessionHandle: %s", p, err)
		}
		if err := p.SessionHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:sessionHandle: %s", p, err)
		}
	}
	return err
}

func (p *TOpenSessionResp) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetConfiguration() {
		if err := oprot.WriteFieldBegin("configuration", thrift.MAP, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:configuration: %s", p, err)
		}
		if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Configuration)); err != nil {
			return fmt.Errorf("error writing map begin: %s", err)
		}
		for k, v := range p.Configuration {
			if err := oprot.WriteString(string(k)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
			if err := oprot.WriteString(string(v)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteMapEnd(); err != nil {
			return fmt.Errorf("error writing map end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:configuration: %s", p, err)
		}
	}
	return err
}

func (p *TOpenSessionResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TOpenSessionResp(%+v)", *p)
}

type TCloseSessionReq struct {
	SessionHandle *TSessionHandle `thrift:"sessionHandle,1,required" json:"sessionHandle"`
}

func NewTCloseSessionReq() *TCloseSessionReq {
	return &TCloseSessionReq{}
}

var TCloseSessionReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TCloseSessionReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TCloseSessionReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}
func (p *TCloseSessionReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TCloseSessionReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCloseSessionReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TCloseSessionReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCloseSessionReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCloseSessionReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TCloseSessionReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCloseSessionReq(%+v)", *p)
}

type TCloseSessionResp struct {
	Status *TStatus `thrift:"status,1,required" json:"status"`
}

func NewTCloseSessionResp() *TCloseSessionResp {
	return &TCloseSessionResp{}
}

var TCloseSessionResp_Status_DEFAULT *TStatus

func (p *TCloseSessionResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TCloseSessionResp_Status_DEFAULT
	}
	return p.Status
}
func (p *TCloseSessionResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TCloseSessionResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCloseSessionResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TCloseSessionResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCloseSessionResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCloseSessionResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TCloseSessionResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCloseSessionResp(%+v)", *p)
}

type TGetInfoValue struct {
	StringValue    string `thrift:"stringValue,1" json:"stringValue"`
	SmallIntValue  int16  `thrift:"smallIntValue,2" json:"smallIntValue"`
	IntegerBitmask int32  `thrift:"integerBitmask,3" json:"integerBitmask"`
	IntegerFlag    int32  `thrift:"integerFlag,4" json:"integerFlag"`
	BinaryValue    int32  `thrift:"binaryValue,5" json:"binaryValue"`
	LenValue       int64  `thrift:"lenValue,6" json:"lenValue"`
}

func NewTGetInfoValue() *TGetInfoValue {
	return &TGetInfoValue{}
}

func (p *TGetInfoValue) GetStringValue() string {
	return p.StringValue
}

func (p *TGetInfoValue) GetSmallIntValue() int16 {
	return p.SmallIntValue
}

func (p *TGetInfoValue) GetIntegerBitmask() int32 {
	return p.IntegerBitmask
}

func (p *TGetInfoValue) GetIntegerFlag() int32 {
	return p.IntegerFlag
}

func (p *TGetInfoValue) GetBinaryValue() int32 {
	return p.BinaryValue
}

func (p *TGetInfoValue) GetLenValue() int64 {
	return p.LenValue
}
func (p *TGetInfoValue) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetInfoValue) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.StringValue = v
	}
	return nil
}

func (p *TGetInfoValue) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.SmallIntValue = v
	}
	return nil
}

func (p *TGetInfoValue) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.IntegerBitmask = v
	}
	return nil
}

func (p *TGetInfoValue) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.IntegerFlag = v
	}
	return nil
}

func (p *TGetInfoValue) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.BinaryValue = v
	}
	return nil
}

func (p *TGetInfoValue) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		p.LenValue = v
	}
	return nil
}

func (p *TGetInfoValue) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetInfoValue"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetInfoValue) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("stringValue", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:stringValue: %s", p, err)
	}
	if err := oprot.WriteString(string(p.StringValue)); err != nil {
		return fmt.Errorf("%T.stringValue (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:stringValue: %s", p, err)
	}
	return err
}

func (p *TGetInfoValue) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("smallIntValue", thrift.I16, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:smallIntValue: %s", p, err)
	}
	if err := oprot.WriteI16(int16(p.SmallIntValue)); err != nil {
		return fmt.Errorf("%T.smallIntValue (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:smallIntValue: %s", p, err)
	}
	return err
}

func (p *TGetInfoValue) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("integerBitmask", thrift.I32, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:integerBitmask: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.IntegerBitmask)); err != nil {
		return fmt.Errorf("%T.integerBitmask (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:integerBitmask: %s", p, err)
	}
	return err
}

func (p *TGetInfoValue) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("integerFlag", thrift.I32, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:integerFlag: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.IntegerFlag)); err != nil {
		return fmt.Errorf("%T.integerFlag (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:integerFlag: %s", p, err)
	}
	return err
}

func (p *TGetInfoValue) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("binaryValue", thrift.I32, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:binaryValue: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.BinaryValue)); err != nil {
		return fmt.Errorf("%T.binaryValue (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:binaryValue: %s", p, err)
	}
	return err
}

func (p *TGetInfoValue) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("lenValue", thrift.I64, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:lenValue: %s", p, err)
	}
	if err := oprot.WriteI64(int64(p.LenValue)); err != nil {
		return fmt.Errorf("%T.lenValue (6) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:lenValue: %s", p, err)
	}
	return err
}

func (p *TGetInfoValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetInfoValue(%+v)", *p)
}

type TGetInfoReq struct {
	SessionHandle *TSessionHandle `thrift:"sessionHandle,1,required" json:"sessionHandle"`
	InfoType      TGetInfoType    `thrift:"infoType,2,required" json:"infoType"`
}

func NewTGetInfoReq() *TGetInfoReq {
	return &TGetInfoReq{}
}

var TGetInfoReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetInfoReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetInfoReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

func (p *TGetInfoReq) GetInfoType() TGetInfoType {
	return p.InfoType
}
func (p *TGetInfoReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetInfoReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetInfoReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetInfoReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TGetInfoType(v)
		p.InfoType = temp
	}
	return nil
}

func (p *TGetInfoReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetInfoReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetInfoReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetInfoReq) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("infoType", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:infoType: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.InfoType)); err != nil {
		return fmt.Errorf("%T.infoType (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:infoType: %s", p, err)
	}
	return err
}

func (p *TGetInfoReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetInfoReq(%+v)", *p)
}

type TGetInfoResp struct {
	Status    *TStatus       `thrift:"status,1,required" json:"status"`
	InfoValue *TGetInfoValue `thrift:"infoValue,2,required" json:"infoValue"`
}

func NewTGetInfoResp() *TGetInfoResp {
	return &TGetInfoResp{}
}

var TGetInfoResp_Status_DEFAULT *TStatus

func (p *TGetInfoResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetInfoResp_Status_DEFAULT
	}
	return p.Status
}

var TGetInfoResp_InfoValue_DEFAULT *TGetInfoValue

func (p *TGetInfoResp) GetInfoValue() *TGetInfoValue {
	if !p.IsSetInfoValue() {
		return TGetInfoResp_InfoValue_DEFAULT
	}
	return p.InfoValue
}
func (p *TGetInfoResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetInfoResp) IsSetInfoValue() bool {
	return p.InfoValue != nil
}

func (p *TGetInfoResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetInfoResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetInfoResp) ReadField2(iprot thrift.TProtocol) error {
	p.InfoValue = &TGetInfoValue{}
	if err := p.InfoValue.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.InfoValue, err)
	}
	return nil
}

func (p *TGetInfoResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetInfoResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetInfoResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetInfoResp) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("infoValue", thrift.STRUCT, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:infoValue: %s", p, err)
	}
	if err := p.InfoValue.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.InfoValue, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:infoValue: %s", p, err)
	}
	return err
}

func (p *TGetInfoResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetInfoResp(%+v)", *p)
}

type TExecuteStatementReq struct {
	SessionHandle *TSessionHandle   `thrift:"sessionHandle,1,required" json:"sessionHandle"`
	Statement     string            `thrift:"statement,2,required" json:"statement"`
	ConfOverlay   map[string]string `thrift:"confOverlay,3" json:"confOverlay"`
}

func NewTExecuteStatementReq() *TExecuteStatementReq {
	return &TExecuteStatementReq{}
}

var TExecuteStatementReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TExecuteStatementReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TExecuteStatementReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

func (p *TExecuteStatementReq) GetStatement() string {
	return p.Statement
}

var TExecuteStatementReq_ConfOverlay_DEFAULT map[string]string

func (p *TExecuteStatementReq) GetConfOverlay() map[string]string {
	return p.ConfOverlay
}
func (p *TExecuteStatementReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TExecuteStatementReq) IsSetConfOverlay() bool {
	return p.ConfOverlay != nil
}

func (p *TExecuteStatementReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TExecuteStatementReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TExecuteStatementReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Statement = v
	}
	return nil
}

func (p *TExecuteStatementReq) ReadField3(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return fmt.Errorf("error reading map begin: %s", err)
	}
	tMap := make(map[string]string, size)
	p.ConfOverlay = tMap
	for i := 0; i < size; i++ {
		var _key21 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_key21 = v
		}
		var _val22 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_val22 = v
		}
		p.ConfOverlay[_key21] = _val22
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return fmt.Errorf("error reading map end: %s", err)
	}
	return nil
}

func (p *TExecuteStatementReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TExecuteStatementReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TExecuteStatementReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TExecuteStatementReq) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("statement", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:statement: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Statement)); err != nil {
		return fmt.Errorf("%T.statement (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:statement: %s", p, err)
	}
	return err
}

func (p *TExecuteStatementReq) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetConfOverlay() {
		if err := oprot.WriteFieldBegin("confOverlay", thrift.MAP, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:confOverlay: %s", p, err)
		}
		if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.ConfOverlay)); err != nil {
			return fmt.Errorf("error writing map begin: %s", err)
		}
		for k, v := range p.ConfOverlay {
			if err := oprot.WriteString(string(k)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
			if err := oprot.WriteString(string(v)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteMapEnd(); err != nil {
			return fmt.Errorf("error writing map end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:confOverlay: %s", p, err)
		}
	}
	return err
}

func (p *TExecuteStatementReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TExecuteStatementReq(%+v)", *p)
}

type TExecuteStatementResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTExecuteStatementResp() *TExecuteStatementResp {
	return &TExecuteStatementResp{}
}

var TExecuteStatementResp_Status_DEFAULT *TStatus

func (p *TExecuteStatementResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TExecuteStatementResp_Status_DEFAULT
	}
	return p.Status
}

var TExecuteStatementResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TExecuteStatementResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TExecuteStatementResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TExecuteStatementResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TExecuteStatementResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TExecuteStatementResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TExecuteStatementResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TExecuteStatementResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TExecuteStatementResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TExecuteStatementResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TExecuteStatementResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TExecuteStatementResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TExecuteStatementResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TExecuteStatementResp(%+v)", *p)
}

type TGetTypeInfoReq struct {
	SessionHandle *TSessionHandle `thrift:"sessionHandle,1,required" json:"sessionHandle"`
}

func NewTGetTypeInfoReq() *TGetTypeInfoReq {
	return &TGetTypeInfoReq{}
}

var TGetTypeInfoReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetTypeInfoReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetTypeInfoReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}
func (p *TGetTypeInfoReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetTypeInfoReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetTypeInfoReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetTypeInfoReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetTypeInfoReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetTypeInfoReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetTypeInfoReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetTypeInfoReq(%+v)", *p)
}

type TGetTypeInfoResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetTypeInfoResp() *TGetTypeInfoResp {
	return &TGetTypeInfoResp{}
}

var TGetTypeInfoResp_Status_DEFAULT *TStatus

func (p *TGetTypeInfoResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetTypeInfoResp_Status_DEFAULT
	}
	return p.Status
}

var TGetTypeInfoResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetTypeInfoResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetTypeInfoResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetTypeInfoResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetTypeInfoResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetTypeInfoResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetTypeInfoResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetTypeInfoResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetTypeInfoResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetTypeInfoResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetTypeInfoResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetTypeInfoResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetTypeInfoResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetTypeInfoResp(%+v)", *p)
}

type TGetCatalogsReq struct {
	SessionHandle *TSessionHandle `thrift:"sessionHandle,1,required" json:"sessionHandle"`
}

func NewTGetCatalogsReq() *TGetCatalogsReq {
	return &TGetCatalogsReq{}
}

var TGetCatalogsReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetCatalogsReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetCatalogsReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}
func (p *TGetCatalogsReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetCatalogsReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetCatalogsReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetCatalogsReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetCatalogsReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetCatalogsReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetCatalogsReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetCatalogsReq(%+v)", *p)
}

type TGetCatalogsResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetCatalogsResp() *TGetCatalogsResp {
	return &TGetCatalogsResp{}
}

var TGetCatalogsResp_Status_DEFAULT *TStatus

func (p *TGetCatalogsResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetCatalogsResp_Status_DEFAULT
	}
	return p.Status
}

var TGetCatalogsResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetCatalogsResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetCatalogsResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetCatalogsResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetCatalogsResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetCatalogsResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetCatalogsResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetCatalogsResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetCatalogsResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetCatalogsResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetCatalogsResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetCatalogsResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetCatalogsResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetCatalogsResp(%+v)", *p)
}

type TGetSchemasReq struct {
	SessionHandle *TSessionHandle       `thrift:"sessionHandle,1,required" json:"sessionHandle"`
	CatalogName   *TIdentifier          `thrift:"catalogName,2" json:"catalogName"`
	SchemaName    *TPatternOrIdentifier `thrift:"schemaName,3" json:"schemaName"`
}

func NewTGetSchemasReq() *TGetSchemasReq {
	return &TGetSchemasReq{}
}

var TGetSchemasReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetSchemasReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetSchemasReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

var TGetSchemasReq_CatalogName_DEFAULT TIdentifier

func (p *TGetSchemasReq) GetCatalogName() TIdentifier {
	if !p.IsSetCatalogName() {
		return TGetSchemasReq_CatalogName_DEFAULT
	}
	return *p.CatalogName
}

var TGetSchemasReq_SchemaName_DEFAULT TPatternOrIdentifier

func (p *TGetSchemasReq) GetSchemaName() TPatternOrIdentifier {
	if !p.IsSetSchemaName() {
		return TGetSchemasReq_SchemaName_DEFAULT
	}
	return *p.SchemaName
}
func (p *TGetSchemasReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetSchemasReq) IsSetCatalogName() bool {
	return p.CatalogName != nil
}

func (p *TGetSchemasReq) IsSetSchemaName() bool {
	return p.SchemaName != nil
}

func (p *TGetSchemasReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetSchemasReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetSchemasReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TIdentifier(v)
		p.CatalogName = &temp
	}
	return nil
}

func (p *TGetSchemasReq) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.SchemaName = &temp
	}
	return nil
}

func (p *TGetSchemasReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetSchemasReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetSchemasReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetSchemasReq) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCatalogName() {
		if err := oprot.WriteFieldBegin("catalogName", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:catalogName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.CatalogName)); err != nil {
			return fmt.Errorf("%T.catalogName (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:catalogName: %s", p, err)
		}
	}
	return err
}

func (p *TGetSchemasReq) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSchemaName() {
		if err := oprot.WriteFieldBegin("schemaName", thrift.STRING, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:schemaName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.SchemaName)); err != nil {
			return fmt.Errorf("%T.schemaName (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:schemaName: %s", p, err)
		}
	}
	return err
}

func (p *TGetSchemasReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetSchemasReq(%+v)", *p)
}

type TGetSchemasResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetSchemasResp() *TGetSchemasResp {
	return &TGetSchemasResp{}
}

var TGetSchemasResp_Status_DEFAULT *TStatus

func (p *TGetSchemasResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetSchemasResp_Status_DEFAULT
	}
	return p.Status
}

var TGetSchemasResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetSchemasResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetSchemasResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetSchemasResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetSchemasResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetSchemasResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetSchemasResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetSchemasResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetSchemasResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetSchemasResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetSchemasResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetSchemasResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetSchemasResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetSchemasResp(%+v)", *p)
}

type TGetTablesReq struct {
	SessionHandle *TSessionHandle       `thrift:"sessionHandle,1,required" json:"sessionHandle"`
	CatalogName   *TPatternOrIdentifier `thrift:"catalogName,2" json:"catalogName"`
	SchemaName    *TPatternOrIdentifier `thrift:"schemaName,3" json:"schemaName"`
	TableName     *TPatternOrIdentifier `thrift:"tableName,4" json:"tableName"`
	TableTypes    []string              `thrift:"tableTypes,5" json:"tableTypes"`
}

func NewTGetTablesReq() *TGetTablesReq {
	return &TGetTablesReq{}
}

var TGetTablesReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetTablesReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetTablesReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

var TGetTablesReq_CatalogName_DEFAULT TPatternOrIdentifier

func (p *TGetTablesReq) GetCatalogName() TPatternOrIdentifier {
	if !p.IsSetCatalogName() {
		return TGetTablesReq_CatalogName_DEFAULT
	}
	return *p.CatalogName
}

var TGetTablesReq_SchemaName_DEFAULT TPatternOrIdentifier

func (p *TGetTablesReq) GetSchemaName() TPatternOrIdentifier {
	if !p.IsSetSchemaName() {
		return TGetTablesReq_SchemaName_DEFAULT
	}
	return *p.SchemaName
}

var TGetTablesReq_TableName_DEFAULT TPatternOrIdentifier

func (p *TGetTablesReq) GetTableName() TPatternOrIdentifier {
	if !p.IsSetTableName() {
		return TGetTablesReq_TableName_DEFAULT
	}
	return *p.TableName
}

var TGetTablesReq_TableTypes_DEFAULT []string

func (p *TGetTablesReq) GetTableTypes() []string {
	return p.TableTypes
}
func (p *TGetTablesReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetTablesReq) IsSetCatalogName() bool {
	return p.CatalogName != nil
}

func (p *TGetTablesReq) IsSetSchemaName() bool {
	return p.SchemaName != nil
}

func (p *TGetTablesReq) IsSetTableName() bool {
	return p.TableName != nil
}

func (p *TGetTablesReq) IsSetTableTypes() bool {
	return p.TableTypes != nil
}

func (p *TGetTablesReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetTablesReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetTablesReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.CatalogName = &temp
	}
	return nil
}

func (p *TGetTablesReq) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.SchemaName = &temp
	}
	return nil
}

func (p *TGetTablesReq) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.TableName = &temp
	}
	return nil
}

func (p *TGetTablesReq) ReadField5(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]string, 0, size)
	p.TableTypes = tSlice
	for i := 0; i < size; i++ {
		var _elem23 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_elem23 = v
		}
		p.TableTypes = append(p.TableTypes, _elem23)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TGetTablesReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetTablesReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetTablesReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetTablesReq) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCatalogName() {
		if err := oprot.WriteFieldBegin("catalogName", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:catalogName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.CatalogName)); err != nil {
			return fmt.Errorf("%T.catalogName (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:catalogName: %s", p, err)
		}
	}
	return err
}

func (p *TGetTablesReq) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSchemaName() {
		if err := oprot.WriteFieldBegin("schemaName", thrift.STRING, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:schemaName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.SchemaName)); err != nil {
			return fmt.Errorf("%T.schemaName (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:schemaName: %s", p, err)
		}
	}
	return err
}

func (p *TGetTablesReq) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetTableName() {
		if err := oprot.WriteFieldBegin("tableName", thrift.STRING, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:tableName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.TableName)); err != nil {
			return fmt.Errorf("%T.tableName (4) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:tableName: %s", p, err)
		}
	}
	return err
}

func (p *TGetTablesReq) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetTableTypes() {
		if err := oprot.WriteFieldBegin("tableTypes", thrift.LIST, 5); err != nil {
			return fmt.Errorf("%T write field begin error 5:tableTypes: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.TableTypes)); err != nil {
			return fmt.Errorf("error writing list begin: %s", err)
		}
		for _, v := range p.TableTypes {
			if err := oprot.WriteString(string(v)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 5:tableTypes: %s", p, err)
		}
	}
	return err
}

func (p *TGetTablesReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetTablesReq(%+v)", *p)
}

type TGetTablesResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetTablesResp() *TGetTablesResp {
	return &TGetTablesResp{}
}

var TGetTablesResp_Status_DEFAULT *TStatus

func (p *TGetTablesResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetTablesResp_Status_DEFAULT
	}
	return p.Status
}

var TGetTablesResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetTablesResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetTablesResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetTablesResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetTablesResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetTablesResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetTablesResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetTablesResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetTablesResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetTablesResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetTablesResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetTablesResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetTablesResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetTablesResp(%+v)", *p)
}

type TGetTableTypesReq struct {
	SessionHandle *TSessionHandle `thrift:"sessionHandle,1,required" json:"sessionHandle"`
}

func NewTGetTableTypesReq() *TGetTableTypesReq {
	return &TGetTableTypesReq{}
}

var TGetTableTypesReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetTableTypesReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetTableTypesReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}
func (p *TGetTableTypesReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetTableTypesReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetTableTypesReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetTableTypesReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetTableTypesReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetTableTypesReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetTableTypesReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetTableTypesReq(%+v)", *p)
}

type TGetTableTypesResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetTableTypesResp() *TGetTableTypesResp {
	return &TGetTableTypesResp{}
}

var TGetTableTypesResp_Status_DEFAULT *TStatus

func (p *TGetTableTypesResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetTableTypesResp_Status_DEFAULT
	}
	return p.Status
}

var TGetTableTypesResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetTableTypesResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetTableTypesResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetTableTypesResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetTableTypesResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetTableTypesResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetTableTypesResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetTableTypesResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetTableTypesResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetTableTypesResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetTableTypesResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetTableTypesResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetTableTypesResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetTableTypesResp(%+v)", *p)
}

type TGetColumnsReq struct {
	SessionHandle *TSessionHandle       `thrift:"sessionHandle,1,required" json:"sessionHandle"`
	CatalogName   *TIdentifier          `thrift:"catalogName,2" json:"catalogName"`
	SchemaName    *TPatternOrIdentifier `thrift:"schemaName,3" json:"schemaName"`
	TableName     *TPatternOrIdentifier `thrift:"tableName,4" json:"tableName"`
	ColumnName    *TPatternOrIdentifier `thrift:"columnName,5" json:"columnName"`
}

func NewTGetColumnsReq() *TGetColumnsReq {
	return &TGetColumnsReq{}
}

var TGetColumnsReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetColumnsReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetColumnsReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

var TGetColumnsReq_CatalogName_DEFAULT TIdentifier

func (p *TGetColumnsReq) GetCatalogName() TIdentifier {
	if !p.IsSetCatalogName() {
		return TGetColumnsReq_CatalogName_DEFAULT
	}
	return *p.CatalogName
}

var TGetColumnsReq_SchemaName_DEFAULT TPatternOrIdentifier

func (p *TGetColumnsReq) GetSchemaName() TPatternOrIdentifier {
	if !p.IsSetSchemaName() {
		return TGetColumnsReq_SchemaName_DEFAULT
	}
	return *p.SchemaName
}

var TGetColumnsReq_TableName_DEFAULT TPatternOrIdentifier

func (p *TGetColumnsReq) GetTableName() TPatternOrIdentifier {
	if !p.IsSetTableName() {
		return TGetColumnsReq_TableName_DEFAULT
	}
	return *p.TableName
}

var TGetColumnsReq_ColumnName_DEFAULT TPatternOrIdentifier

func (p *TGetColumnsReq) GetColumnName() TPatternOrIdentifier {
	if !p.IsSetColumnName() {
		return TGetColumnsReq_ColumnName_DEFAULT
	}
	return *p.ColumnName
}
func (p *TGetColumnsReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetColumnsReq) IsSetCatalogName() bool {
	return p.CatalogName != nil
}

func (p *TGetColumnsReq) IsSetSchemaName() bool {
	return p.SchemaName != nil
}

func (p *TGetColumnsReq) IsSetTableName() bool {
	return p.TableName != nil
}

func (p *TGetColumnsReq) IsSetColumnName() bool {
	return p.ColumnName != nil
}

func (p *TGetColumnsReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetColumnsReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetColumnsReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TIdentifier(v)
		p.CatalogName = &temp
	}
	return nil
}

func (p *TGetColumnsReq) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.SchemaName = &temp
	}
	return nil
}

func (p *TGetColumnsReq) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.TableName = &temp
	}
	return nil
}

func (p *TGetColumnsReq) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.ColumnName = &temp
	}
	return nil
}

func (p *TGetColumnsReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetColumnsReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetColumnsReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetColumnsReq) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCatalogName() {
		if err := oprot.WriteFieldBegin("catalogName", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:catalogName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.CatalogName)); err != nil {
			return fmt.Errorf("%T.catalogName (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:catalogName: %s", p, err)
		}
	}
	return err
}

func (p *TGetColumnsReq) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSchemaName() {
		if err := oprot.WriteFieldBegin("schemaName", thrift.STRING, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:schemaName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.SchemaName)); err != nil {
			return fmt.Errorf("%T.schemaName (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:schemaName: %s", p, err)
		}
	}
	return err
}

func (p *TGetColumnsReq) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetTableName() {
		if err := oprot.WriteFieldBegin("tableName", thrift.STRING, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:tableName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.TableName)); err != nil {
			return fmt.Errorf("%T.tableName (4) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:tableName: %s", p, err)
		}
	}
	return err
}

func (p *TGetColumnsReq) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetColumnName() {
		if err := oprot.WriteFieldBegin("columnName", thrift.STRING, 5); err != nil {
			return fmt.Errorf("%T write field begin error 5:columnName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.ColumnName)); err != nil {
			return fmt.Errorf("%T.columnName (5) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 5:columnName: %s", p, err)
		}
	}
	return err
}

func (p *TGetColumnsReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetColumnsReq(%+v)", *p)
}

type TGetColumnsResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetColumnsResp() *TGetColumnsResp {
	return &TGetColumnsResp{}
}

var TGetColumnsResp_Status_DEFAULT *TStatus

func (p *TGetColumnsResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetColumnsResp_Status_DEFAULT
	}
	return p.Status
}

var TGetColumnsResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetColumnsResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetColumnsResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetColumnsResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetColumnsResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetColumnsResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetColumnsResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetColumnsResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetColumnsResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetColumnsResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetColumnsResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetColumnsResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetColumnsResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetColumnsResp(%+v)", *p)
}

type TGetFunctionsReq struct {
	SessionHandle *TSessionHandle       `thrift:"sessionHandle,1,required" json:"sessionHandle"`
	CatalogName   *TIdentifier          `thrift:"catalogName,2" json:"catalogName"`
	SchemaName    *TPatternOrIdentifier `thrift:"schemaName,3" json:"schemaName"`
	FunctionName  TPatternOrIdentifier  `thrift:"functionName,4,required" json:"functionName"`
}

func NewTGetFunctionsReq() *TGetFunctionsReq {
	return &TGetFunctionsReq{}
}

var TGetFunctionsReq_SessionHandle_DEFAULT *TSessionHandle

func (p *TGetFunctionsReq) GetSessionHandle() *TSessionHandle {
	if !p.IsSetSessionHandle() {
		return TGetFunctionsReq_SessionHandle_DEFAULT
	}
	return p.SessionHandle
}

var TGetFunctionsReq_CatalogName_DEFAULT TIdentifier

func (p *TGetFunctionsReq) GetCatalogName() TIdentifier {
	if !p.IsSetCatalogName() {
		return TGetFunctionsReq_CatalogName_DEFAULT
	}
	return *p.CatalogName
}

var TGetFunctionsReq_SchemaName_DEFAULT TPatternOrIdentifier

func (p *TGetFunctionsReq) GetSchemaName() TPatternOrIdentifier {
	if !p.IsSetSchemaName() {
		return TGetFunctionsReq_SchemaName_DEFAULT
	}
	return *p.SchemaName
}

func (p *TGetFunctionsReq) GetFunctionName() TPatternOrIdentifier {
	return p.FunctionName
}
func (p *TGetFunctionsReq) IsSetSessionHandle() bool {
	return p.SessionHandle != nil
}

func (p *TGetFunctionsReq) IsSetCatalogName() bool {
	return p.CatalogName != nil
}

func (p *TGetFunctionsReq) IsSetSchemaName() bool {
	return p.SchemaName != nil
}

func (p *TGetFunctionsReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetFunctionsReq) ReadField1(iprot thrift.TProtocol) error {
	p.SessionHandle = &TSessionHandle{}
	if err := p.SessionHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.SessionHandle, err)
	}
	return nil
}

func (p *TGetFunctionsReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TIdentifier(v)
		p.CatalogName = &temp
	}
	return nil
}

func (p *TGetFunctionsReq) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.SchemaName = &temp
	}
	return nil
}

func (p *TGetFunctionsReq) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		temp := TPatternOrIdentifier(v)
		p.FunctionName = temp
	}
	return nil
}

func (p *TGetFunctionsReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetFunctionsReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetFunctionsReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("sessionHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:sessionHandle: %s", p, err)
	}
	if err := p.SessionHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.SessionHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:sessionHandle: %s", p, err)
	}
	return err
}

func (p *TGetFunctionsReq) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCatalogName() {
		if err := oprot.WriteFieldBegin("catalogName", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:catalogName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.CatalogName)); err != nil {
			return fmt.Errorf("%T.catalogName (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:catalogName: %s", p, err)
		}
	}
	return err
}

func (p *TGetFunctionsReq) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSchemaName() {
		if err := oprot.WriteFieldBegin("schemaName", thrift.STRING, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:schemaName: %s", p, err)
		}
		if err := oprot.WriteString(string(*p.SchemaName)); err != nil {
			return fmt.Errorf("%T.schemaName (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:schemaName: %s", p, err)
		}
	}
	return err
}

func (p *TGetFunctionsReq) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("functionName", thrift.STRING, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:functionName: %s", p, err)
	}
	if err := oprot.WriteString(string(p.FunctionName)); err != nil {
		return fmt.Errorf("%T.functionName (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:functionName: %s", p, err)
	}
	return err
}

func (p *TGetFunctionsReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetFunctionsReq(%+v)", *p)
}

type TGetFunctionsResp struct {
	Status          *TStatus          `thrift:"status,1,required" json:"status"`
	OperationHandle *TOperationHandle `thrift:"operationHandle,2" json:"operationHandle"`
}

func NewTGetFunctionsResp() *TGetFunctionsResp {
	return &TGetFunctionsResp{}
}

var TGetFunctionsResp_Status_DEFAULT *TStatus

func (p *TGetFunctionsResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetFunctionsResp_Status_DEFAULT
	}
	return p.Status
}

var TGetFunctionsResp_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetFunctionsResp) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetFunctionsResp_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetFunctionsResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetFunctionsResp) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetFunctionsResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetFunctionsResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetFunctionsResp) ReadField2(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetFunctionsResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetFunctionsResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetFunctionsResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetFunctionsResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationHandle() {
		if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationHandle: %s", p, err)
		}
		if err := p.OperationHandle.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationHandle: %s", p, err)
		}
	}
	return err
}

func (p *TGetFunctionsResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetFunctionsResp(%+v)", *p)
}

type TGetOperationStatusReq struct {
	OperationHandle *TOperationHandle `thrift:"operationHandle,1,required" json:"operationHandle"`
}

func NewTGetOperationStatusReq() *TGetOperationStatusReq {
	return &TGetOperationStatusReq{}
}

var TGetOperationStatusReq_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetOperationStatusReq) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetOperationStatusReq_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetOperationStatusReq) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetOperationStatusReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetOperationStatusReq) ReadField1(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetOperationStatusReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetOperationStatusReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetOperationStatusReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:operationHandle: %s", p, err)
	}
	if err := p.OperationHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:operationHandle: %s", p, err)
	}
	return err
}

func (p *TGetOperationStatusReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetOperationStatusReq(%+v)", *p)
}

type TGetOperationStatusResp struct {
	Status         *TStatus         `thrift:"status,1,required" json:"status"`
	OperationState *TOperationState `thrift:"operationState,2" json:"operationState"`
}

func NewTGetOperationStatusResp() *TGetOperationStatusResp {
	return &TGetOperationStatusResp{}
}

var TGetOperationStatusResp_Status_DEFAULT *TStatus

func (p *TGetOperationStatusResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetOperationStatusResp_Status_DEFAULT
	}
	return p.Status
}

var TGetOperationStatusResp_OperationState_DEFAULT TOperationState

func (p *TGetOperationStatusResp) GetOperationState() TOperationState {
	if !p.IsSetOperationState() {
		return TGetOperationStatusResp_OperationState_DEFAULT
	}
	return *p.OperationState
}
func (p *TGetOperationStatusResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetOperationStatusResp) IsSetOperationState() bool {
	return p.OperationState != nil
}

func (p *TGetOperationStatusResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetOperationStatusResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetOperationStatusResp) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TOperationState(v)
		p.OperationState = &temp
	}
	return nil
}

func (p *TGetOperationStatusResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetOperationStatusResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetOperationStatusResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetOperationStatusResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetOperationState() {
		if err := oprot.WriteFieldBegin("operationState", thrift.I32, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:operationState: %s", p, err)
		}
		if err := oprot.WriteI32(int32(*p.OperationState)); err != nil {
			return fmt.Errorf("%T.operationState (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:operationState: %s", p, err)
		}
	}
	return err
}

func (p *TGetOperationStatusResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetOperationStatusResp(%+v)", *p)
}

type TCancelOperationReq struct {
	OperationHandle *TOperationHandle `thrift:"operationHandle,1,required" json:"operationHandle"`
}

func NewTCancelOperationReq() *TCancelOperationReq {
	return &TCancelOperationReq{}
}

var TCancelOperationReq_OperationHandle_DEFAULT *TOperationHandle

func (p *TCancelOperationReq) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TCancelOperationReq_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TCancelOperationReq) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TCancelOperationReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCancelOperationReq) ReadField1(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TCancelOperationReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCancelOperationReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCancelOperationReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:operationHandle: %s", p, err)
	}
	if err := p.OperationHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:operationHandle: %s", p, err)
	}
	return err
}

func (p *TCancelOperationReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCancelOperationReq(%+v)", *p)
}

type TCancelOperationResp struct {
	Status *TStatus `thrift:"status,1,required" json:"status"`
}

func NewTCancelOperationResp() *TCancelOperationResp {
	return &TCancelOperationResp{}
}

var TCancelOperationResp_Status_DEFAULT *TStatus

func (p *TCancelOperationResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TCancelOperationResp_Status_DEFAULT
	}
	return p.Status
}
func (p *TCancelOperationResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TCancelOperationResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCancelOperationResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TCancelOperationResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCancelOperationResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCancelOperationResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TCancelOperationResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCancelOperationResp(%+v)", *p)
}

type TCloseOperationReq struct {
	OperationHandle *TOperationHandle `thrift:"operationHandle,1,required" json:"operationHandle"`
}

func NewTCloseOperationReq() *TCloseOperationReq {
	return &TCloseOperationReq{}
}

var TCloseOperationReq_OperationHandle_DEFAULT *TOperationHandle

func (p *TCloseOperationReq) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TCloseOperationReq_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TCloseOperationReq) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TCloseOperationReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCloseOperationReq) ReadField1(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TCloseOperationReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCloseOperationReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCloseOperationReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:operationHandle: %s", p, err)
	}
	if err := p.OperationHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:operationHandle: %s", p, err)
	}
	return err
}

func (p *TCloseOperationReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCloseOperationReq(%+v)", *p)
}

type TCloseOperationResp struct {
	Status *TStatus `thrift:"status,1,required" json:"status"`
}

func NewTCloseOperationResp() *TCloseOperationResp {
	return &TCloseOperationResp{}
}

var TCloseOperationResp_Status_DEFAULT *TStatus

func (p *TCloseOperationResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TCloseOperationResp_Status_DEFAULT
	}
	return p.Status
}
func (p *TCloseOperationResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TCloseOperationResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCloseOperationResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TCloseOperationResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCloseOperationResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCloseOperationResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TCloseOperationResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCloseOperationResp(%+v)", *p)
}

type TGetResultSetMetadataReq struct {
	OperationHandle *TOperationHandle `thrift:"operationHandle,1,required" json:"operationHandle"`
}

func NewTGetResultSetMetadataReq() *TGetResultSetMetadataReq {
	return &TGetResultSetMetadataReq{}
}

var TGetResultSetMetadataReq_OperationHandle_DEFAULT *TOperationHandle

func (p *TGetResultSetMetadataReq) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TGetResultSetMetadataReq_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}
func (p *TGetResultSetMetadataReq) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TGetResultSetMetadataReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetResultSetMetadataReq) ReadField1(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TGetResultSetMetadataReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetResultSetMetadataReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetResultSetMetadataReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:operationHandle: %s", p, err)
	}
	if err := p.OperationHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:operationHandle: %s", p, err)
	}
	return err
}

func (p *TGetResultSetMetadataReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetResultSetMetadataReq(%+v)", *p)
}

type TGetResultSetMetadataResp struct {
	Status *TStatus      `thrift:"status,1,required" json:"status"`
	Schema *TTableSchema `thrift:"schema,2" json:"schema"`
}

func NewTGetResultSetMetadataResp() *TGetResultSetMetadataResp {
	return &TGetResultSetMetadataResp{}
}

var TGetResultSetMetadataResp_Status_DEFAULT *TStatus

func (p *TGetResultSetMetadataResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TGetResultSetMetadataResp_Status_DEFAULT
	}
	return p.Status
}

var TGetResultSetMetadataResp_Schema_DEFAULT *TTableSchema

func (p *TGetResultSetMetadataResp) GetSchema() *TTableSchema {
	if !p.IsSetSchema() {
		return TGetResultSetMetadataResp_Schema_DEFAULT
	}
	return p.Schema
}
func (p *TGetResultSetMetadataResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TGetResultSetMetadataResp) IsSetSchema() bool {
	return p.Schema != nil
}

func (p *TGetResultSetMetadataResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TGetResultSetMetadataResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TGetResultSetMetadataResp) ReadField2(iprot thrift.TProtocol) error {
	p.Schema = &TTableSchema{}
	if err := p.Schema.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Schema, err)
	}
	return nil
}

func (p *TGetResultSetMetadataResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TGetResultSetMetadataResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TGetResultSetMetadataResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TGetResultSetMetadataResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetSchema() {
		if err := oprot.WriteFieldBegin("schema", thrift.STRUCT, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:schema: %s", p, err)
		}
		if err := p.Schema.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.Schema, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:schema: %s", p, err)
		}
	}
	return err
}

func (p *TGetResultSetMetadataResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TGetResultSetMetadataResp(%+v)", *p)
}

type TFetchResultsReq struct {
	OperationHandle *TOperationHandle `thrift:"operationHandle,1,required" json:"operationHandle"`
	Orientation     TFetchOrientation `thrift:"orientation,2,required" json:"orientation"`
	MaxRows         int64             `thrift:"maxRows,3,required" json:"maxRows"`
}

func NewTFetchResultsReq() *TFetchResultsReq {
	return &TFetchResultsReq{
		Orientation: 0,
	}
}

var TFetchResultsReq_OperationHandle_DEFAULT *TOperationHandle

func (p *TFetchResultsReq) GetOperationHandle() *TOperationHandle {
	if !p.IsSetOperationHandle() {
		return TFetchResultsReq_OperationHandle_DEFAULT
	}
	return p.OperationHandle
}

func (p *TFetchResultsReq) GetOrientation() TFetchOrientation {
	return p.Orientation
}

func (p *TFetchResultsReq) GetMaxRows() int64 {
	return p.MaxRows
}
func (p *TFetchResultsReq) IsSetOperationHandle() bool {
	return p.OperationHandle != nil
}

func (p *TFetchResultsReq) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TFetchResultsReq) ReadField1(iprot thrift.TProtocol) error {
	p.OperationHandle = &TOperationHandle{}
	if err := p.OperationHandle.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.OperationHandle, err)
	}
	return nil
}

func (p *TFetchResultsReq) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := TFetchOrientation(v)
		p.Orientation = temp
	}
	return nil
}

func (p *TFetchResultsReq) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.MaxRows = v
	}
	return nil
}

func (p *TFetchResultsReq) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TFetchResultsReq"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TFetchResultsReq) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("operationHandle", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:operationHandle: %s", p, err)
	}
	if err := p.OperationHandle.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.OperationHandle, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:operationHandle: %s", p, err)
	}
	return err
}

func (p *TFetchResultsReq) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("orientation", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:orientation: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Orientation)); err != nil {
		return fmt.Errorf("%T.orientation (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:orientation: %s", p, err)
	}
	return err
}

func (p *TFetchResultsReq) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("maxRows", thrift.I64, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:maxRows: %s", p, err)
	}
	if err := oprot.WriteI64(int64(p.MaxRows)); err != nil {
		return fmt.Errorf("%T.maxRows (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:maxRows: %s", p, err)
	}
	return err
}

func (p *TFetchResultsReq) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TFetchResultsReq(%+v)", *p)
}

type TFetchResultsResp struct {
	Status      *TStatus `thrift:"status,1,required" json:"status"`
	HasMoreRows *bool    `thrift:"hasMoreRows,2" json:"hasMoreRows"`
	Results     *TRowSet `thrift:"results,3" json:"results"`
}

func NewTFetchResultsResp() *TFetchResultsResp {
	return &TFetchResultsResp{}
}

var TFetchResultsResp_Status_DEFAULT *TStatus

func (p *TFetchResultsResp) GetStatus() *TStatus {
	if !p.IsSetStatus() {
		return TFetchResultsResp_Status_DEFAULT
	}
	return p.Status
}

var TFetchResultsResp_HasMoreRows_DEFAULT bool

func (p *TFetchResultsResp) GetHasMoreRows() bool {
	if !p.IsSetHasMoreRows() {
		return TFetchResultsResp_HasMoreRows_DEFAULT
	}
	return *p.HasMoreRows
}

var TFetchResultsResp_Results_DEFAULT *TRowSet

func (p *TFetchResultsResp) GetResults() *TRowSet {
	if !p.IsSetResults() {
		return TFetchResultsResp_Results_DEFAULT
	}
	return p.Results
}
func (p *TFetchResultsResp) IsSetStatus() bool {
	return p.Status != nil
}

func (p *TFetchResultsResp) IsSetHasMoreRows() bool {
	return p.HasMoreRows != nil
}

func (p *TFetchResultsResp) IsSetResults() bool {
	return p.Results != nil
}

func (p *TFetchResultsResp) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TFetchResultsResp) ReadField1(iprot thrift.TProtocol) error {
	p.Status = &TStatus{}
	if err := p.Status.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Status, err)
	}
	return nil
}

func (p *TFetchResultsResp) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.HasMoreRows = &v
	}
	return nil
}

func (p *TFetchResultsResp) ReadField3(iprot thrift.TProtocol) error {
	p.Results = &TRowSet{}
	if err := p.Results.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Results, err)
	}
	return nil
}

func (p *TFetchResultsResp) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TFetchResultsResp"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TFetchResultsResp) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:status: %s", p, err)
	}
	if err := p.Status.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Status, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:status: %s", p, err)
	}
	return err
}

func (p *TFetchResultsResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetHasMoreRows() {
		if err := oprot.WriteFieldBegin("hasMoreRows", thrift.BOOL, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:hasMoreRows: %s", p, err)
		}
		if err := oprot.WriteBool(bool(*p.HasMoreRows)); err != nil {
			return fmt.Errorf("%T.hasMoreRows (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:hasMoreRows: %s", p, err)
		}
	}
	return err
}

func (p *TFetchResultsResp) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetResults() {
		if err := oprot.WriteFieldBegin("results", thrift.STRUCT, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:results: %s", p, err)
		}
		if err := p.Results.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.Results, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:results: %s", p, err)
		}
	}
	return err
}

func (p *TFetchResultsResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TFetchResultsResp(%+v)", *p)
}