http://git-wip-us.apache.org/repos/asf/hive/blob/a28f6cd8/service/src/gen/thrift/gen-cpp/TCLIService_types.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_types.h b/service/src/gen/thrift/gen-cpp/TCLIService_types.h new file mode 100644 index 0000000..b078c99 --- /dev/null +++ b/service/src/gen/thrift/gen-cpp/TCLIService_types.h @@ -0,0 +1,4141 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef TCLIService_TYPES_H +#define TCLIService_TYPES_H + +#include <iosfwd> + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + +#include <thrift/cxxfunctional.h> + + +namespace apache { namespace hive { namespace service { namespace cli { namespace thrift { + +struct TProtocolVersion { + enum type { + HIVE_CLI_SERVICE_PROTOCOL_V1 = 0, + HIVE_CLI_SERVICE_PROTOCOL_V2 = 1, + HIVE_CLI_SERVICE_PROTOCOL_V3 = 2, + HIVE_CLI_SERVICE_PROTOCOL_V4 = 3, + HIVE_CLI_SERVICE_PROTOCOL_V5 = 4, + HIVE_CLI_SERVICE_PROTOCOL_V6 = 5, + HIVE_CLI_SERVICE_PROTOCOL_V7 = 6, + HIVE_CLI_SERVICE_PROTOCOL_V8 = 7 + }; +}; + +extern const std::map<int, const char*> _TProtocolVersion_VALUES_TO_NAMES; + +struct TTypeId { + enum type { + BOOLEAN_TYPE = 0, + TINYINT_TYPE = 1, + SMALLINT_TYPE = 2, + INT_TYPE = 3, + BIGINT_TYPE = 4, + FLOAT_TYPE = 5, + DOUBLE_TYPE = 6, + STRING_TYPE = 7, + TIMESTAMP_TYPE = 8, + BINARY_TYPE = 9, + ARRAY_TYPE = 10, + MAP_TYPE = 11, + STRUCT_TYPE = 12, + UNION_TYPE = 13, + USER_DEFINED_TYPE = 14, + DECIMAL_TYPE = 15, + NULL_TYPE = 16, + DATE_TYPE = 17, + VARCHAR_TYPE = 18, + CHAR_TYPE = 19, + INTERVAL_YEAR_MONTH_TYPE = 20, + INTERVAL_DAY_TIME_TYPE = 21 + }; +}; + +extern const std::map<int, const char*> _TTypeId_VALUES_TO_NAMES; + +struct TStatusCode { + enum type { + SUCCESS_STATUS = 0, + SUCCESS_WITH_INFO_STATUS = 1, + STILL_EXECUTING_STATUS = 2, + ERROR_STATUS = 3, + INVALID_HANDLE_STATUS = 4 + }; +}; + +extern const std::map<int, const char*> _TStatusCode_VALUES_TO_NAMES; + +struct TOperationState { + enum type { + INITIALIZED_STATE = 0, + RUNNING_STATE = 1, + FINISHED_STATE = 2, + CANCELED_STATE = 3, + CLOSED_STATE = 4, + ERROR_STATE = 5, + UKNOWN_STATE = 6, + PENDING_STATE = 7 + }; +}; + +extern const std::map<int, const char*> _TOperationState_VALUES_TO_NAMES; + +struct TOperationType { + enum type { + EXECUTE_STATEMENT = 0, + GET_TYPE_INFO = 1, + GET_CATALOGS = 2, + GET_SCHEMAS = 3, + GET_TABLES = 4, + GET_TABLE_TYPES = 5, + GET_COLUMNS = 6, + GET_FUNCTIONS = 7, + UNKNOWN = 8 + }; +}; + +extern const std::map<int, const char*> _TOperationType_VALUES_TO_NAMES; + +struct TGetInfoType { + enum type { + CLI_MAX_DRIVER_CONNECTIONS = 0, + CLI_MAX_CONCURRENT_ACTIVITIES = 1, + CLI_DATA_SOURCE_NAME = 2, + CLI_FETCH_DIRECTION = 8, + CLI_SERVER_NAME = 13, + CLI_SEARCH_PATTERN_ESCAPE = 14, + CLI_DBMS_NAME = 17, + CLI_DBMS_VER = 18, + CLI_ACCESSIBLE_TABLES = 19, + CLI_ACCESSIBLE_PROCEDURES = 20, + CLI_CURSOR_COMMIT_BEHAVIOR = 23, + CLI_DATA_SOURCE_READ_ONLY = 25, + CLI_DEFAULT_TXN_ISOLATION = 26, + CLI_IDENTIFIER_CASE = 28, + CLI_IDENTIFIER_QUOTE_CHAR = 29, + CLI_MAX_COLUMN_NAME_LEN = 30, + CLI_MAX_CURSOR_NAME_LEN = 31, + CLI_MAX_SCHEMA_NAME_LEN = 32, + CLI_MAX_CATALOG_NAME_LEN = 34, + CLI_MAX_TABLE_NAME_LEN = 35, + CLI_SCROLL_CONCURRENCY = 43, + CLI_TXN_CAPABLE = 46, + CLI_USER_NAME = 47, + CLI_TXN_ISOLATION_OPTION = 72, + CLI_INTEGRITY = 73, + CLI_GETDATA_EXTENSIONS = 81, + CLI_NULL_COLLATION = 85, + CLI_ALTER_TABLE = 86, + CLI_ORDER_BY_COLUMNS_IN_SELECT = 90, + CLI_SPECIAL_CHARACTERS = 94, + CLI_MAX_COLUMNS_IN_GROUP_BY = 97, + CLI_MAX_COLUMNS_IN_INDEX = 98, + CLI_MAX_COLUMNS_IN_ORDER_BY = 99, + CLI_MAX_COLUMNS_IN_SELECT = 100, + CLI_MAX_COLUMNS_IN_TABLE = 101, + CLI_MAX_INDEX_SIZE = 102, + CLI_MAX_ROW_SIZE = 104, + CLI_MAX_STATEMENT_LEN = 105, + CLI_MAX_TABLES_IN_SELECT = 106, + CLI_MAX_USER_NAME_LEN = 107, + CLI_OJ_CAPABILITIES = 115, + CLI_XOPEN_CLI_YEAR = 10000, + CLI_CURSOR_SENSITIVITY = 10001, + CLI_DESCRIBE_PARAMETER = 10002, + CLI_CATALOG_NAME = 10003, + CLI_COLLATION_SEQ = 10004, + CLI_MAX_IDENTIFIER_LEN = 10005 + }; +}; + +extern const std::map<int, const char*> _TGetInfoType_VALUES_TO_NAMES; + +struct TFetchOrientation { + enum type { + FETCH_NEXT = 0, + FETCH_PRIOR = 1, + FETCH_RELATIVE = 2, + FETCH_ABSOLUTE = 3, + FETCH_FIRST = 4, + FETCH_LAST = 5 + }; +}; + +extern const std::map<int, const char*> _TFetchOrientation_VALUES_TO_NAMES; + +typedef int32_t TTypeEntryPtr; + +typedef std::string TIdentifier; + +typedef std::string TPattern; + +typedef std::string TPatternOrIdentifier; + +class TTypeQualifierValue; + +class TTypeQualifiers; + +class TPrimitiveTypeEntry; + +class TArrayTypeEntry; + +class TMapTypeEntry; + +class TStructTypeEntry; + +class TUnionTypeEntry; + +class TUserDefinedTypeEntry; + +class TTypeEntry; + +class TTypeDesc; + +class TColumnDesc; + +class TTableSchema; + +class TBoolValue; + +class TByteValue; + +class TI16Value; + +class TI32Value; + +class TI64Value; + +class TDoubleValue; + +class TStringValue; + +class TColumnValue; + +class TRow; + +class TBoolColumn; + +class TByteColumn; + +class TI16Column; + +class TI32Column; + +class TI64Column; + +class TDoubleColumn; + +class TStringColumn; + +class TBinaryColumn; + +class TColumn; + +class TRowSet; + +class TStatus; + +class THandleIdentifier; + +class TSessionHandle; + +class TOperationHandle; + +class TOpenSessionReq; + +class TOpenSessionResp; + +class TCloseSessionReq; + +class TCloseSessionResp; + +class TGetInfoValue; + +class TGetInfoReq; + +class TGetInfoResp; + +class TExecuteStatementReq; + +class TExecuteStatementResp; + +class TGetTypeInfoReq; + +class TGetTypeInfoResp; + +class TGetCatalogsReq; + +class TGetCatalogsResp; + +class TGetSchemasReq; + +class TGetSchemasResp; + +class TGetTablesReq; + +class TGetTablesResp; + +class TGetTableTypesReq; + +class TGetTableTypesResp; + +class TGetColumnsReq; + +class TGetColumnsResp; + +class TGetFunctionsReq; + +class TGetFunctionsResp; + +class TGetOperationStatusReq; + +class TGetOperationStatusResp; + +class TCancelOperationReq; + +class TCancelOperationResp; + +class TCloseOperationReq; + +class TCloseOperationResp; + +class TGetResultSetMetadataReq; + +class TGetResultSetMetadataResp; + +class TFetchResultsReq; + +class TFetchResultsResp; + +class TGetDelegationTokenReq; + +class TGetDelegationTokenResp; + +class TCancelDelegationTokenReq; + +class TCancelDelegationTokenResp; + +class TRenewDelegationTokenReq; + +class TRenewDelegationTokenResp; + +typedef struct _TTypeQualifierValue__isset { + _TTypeQualifierValue__isset() : i32Value(false), stringValue(false) {} + bool i32Value :1; + bool stringValue :1; +} _TTypeQualifierValue__isset; + +class TTypeQualifierValue { + public: + + TTypeQualifierValue(const TTypeQualifierValue&); + TTypeQualifierValue& operator=(const TTypeQualifierValue&); + TTypeQualifierValue() : i32Value(0), stringValue() { + } + + virtual ~TTypeQualifierValue() throw(); + int32_t i32Value; + std::string stringValue; + + _TTypeQualifierValue__isset __isset; + + void __set_i32Value(const int32_t val); + + void __set_stringValue(const std::string& val); + + bool operator == (const TTypeQualifierValue & rhs) const + { + if (__isset.i32Value != rhs.__isset.i32Value) + return false; + else if (__isset.i32Value && !(i32Value == rhs.i32Value)) + return false; + if (__isset.stringValue != rhs.__isset.stringValue) + return false; + else if (__isset.stringValue && !(stringValue == rhs.stringValue)) + return false; + return true; + } + bool operator != (const TTypeQualifierValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTypeQualifierValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TTypeQualifierValue &a, TTypeQualifierValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj) +{ + obj.printTo(out); + return out; +} + + +class TTypeQualifiers { + public: + + TTypeQualifiers(const TTypeQualifiers&); + TTypeQualifiers& operator=(const TTypeQualifiers&); + TTypeQualifiers() { + } + + virtual ~TTypeQualifiers() throw(); + std::map<std::string, TTypeQualifierValue> qualifiers; + + void __set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val); + + bool operator == (const TTypeQualifiers & rhs) const + { + if (!(qualifiers == rhs.qualifiers)) + return false; + return true; + } + bool operator != (const TTypeQualifiers &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTypeQualifiers & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TTypeQualifiers &a, TTypeQualifiers &b); + +inline std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TPrimitiveTypeEntry__isset { + _TPrimitiveTypeEntry__isset() : typeQualifiers(false) {} + bool typeQualifiers :1; +} _TPrimitiveTypeEntry__isset; + +class TPrimitiveTypeEntry { + public: + + TPrimitiveTypeEntry(const TPrimitiveTypeEntry&); + TPrimitiveTypeEntry& operator=(const TPrimitiveTypeEntry&); + TPrimitiveTypeEntry() : type((TTypeId::type)0) { + } + + virtual ~TPrimitiveTypeEntry() throw(); + TTypeId::type type; + TTypeQualifiers typeQualifiers; + + _TPrimitiveTypeEntry__isset __isset; + + void __set_type(const TTypeId::type val); + + void __set_typeQualifiers(const TTypeQualifiers& val); + + bool operator == (const TPrimitiveTypeEntry & rhs) const + { + if (!(type == rhs.type)) + return false; + if (__isset.typeQualifiers != rhs.__isset.typeQualifiers) + return false; + else if (__isset.typeQualifiers && !(typeQualifiers == rhs.typeQualifiers)) + return false; + return true; + } + bool operator != (const TPrimitiveTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TPrimitiveTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + + +class TArrayTypeEntry { + public: + + TArrayTypeEntry(const TArrayTypeEntry&); + TArrayTypeEntry& operator=(const TArrayTypeEntry&); + TArrayTypeEntry() : objectTypePtr(0) { + } + + virtual ~TArrayTypeEntry() throw(); + TTypeEntryPtr objectTypePtr; + + void __set_objectTypePtr(const TTypeEntryPtr val); + + bool operator == (const TArrayTypeEntry & rhs) const + { + if (!(objectTypePtr == rhs.objectTypePtr)) + return false; + return true; + } + bool operator != (const TArrayTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TArrayTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TArrayTypeEntry &a, TArrayTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + + +class TMapTypeEntry { + public: + + TMapTypeEntry(const TMapTypeEntry&); + TMapTypeEntry& operator=(const TMapTypeEntry&); + TMapTypeEntry() : keyTypePtr(0), valueTypePtr(0) { + } + + virtual ~TMapTypeEntry() throw(); + TTypeEntryPtr keyTypePtr; + TTypeEntryPtr valueTypePtr; + + void __set_keyTypePtr(const TTypeEntryPtr val); + + void __set_valueTypePtr(const TTypeEntryPtr val); + + bool operator == (const TMapTypeEntry & rhs) const + { + if (!(keyTypePtr == rhs.keyTypePtr)) + return false; + if (!(valueTypePtr == rhs.valueTypePtr)) + return false; + return true; + } + bool operator != (const TMapTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TMapTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TMapTypeEntry &a, TMapTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + + +class TStructTypeEntry { + public: + + TStructTypeEntry(const TStructTypeEntry&); + TStructTypeEntry& operator=(const TStructTypeEntry&); + TStructTypeEntry() { + } + + virtual ~TStructTypeEntry() throw(); + std::map<std::string, TTypeEntryPtr> nameToTypePtr; + + void __set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val); + + bool operator == (const TStructTypeEntry & rhs) const + { + if (!(nameToTypePtr == rhs.nameToTypePtr)) + return false; + return true; + } + bool operator != (const TStructTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TStructTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TStructTypeEntry &a, TStructTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + + +class TUnionTypeEntry { + public: + + TUnionTypeEntry(const TUnionTypeEntry&); + TUnionTypeEntry& operator=(const TUnionTypeEntry&); + TUnionTypeEntry() { + } + + virtual ~TUnionTypeEntry() throw(); + std::map<std::string, TTypeEntryPtr> nameToTypePtr; + + void __set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val); + + bool operator == (const TUnionTypeEntry & rhs) const + { + if (!(nameToTypePtr == rhs.nameToTypePtr)) + return false; + return true; + } + bool operator != (const TUnionTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TUnionTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TUnionTypeEntry &a, TUnionTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + + +class TUserDefinedTypeEntry { + public: + + TUserDefinedTypeEntry(const TUserDefinedTypeEntry&); + TUserDefinedTypeEntry& operator=(const TUserDefinedTypeEntry&); + TUserDefinedTypeEntry() : typeClassName() { + } + + virtual ~TUserDefinedTypeEntry() throw(); + std::string typeClassName; + + void __set_typeClassName(const std::string& val); + + bool operator == (const TUserDefinedTypeEntry & rhs) const + { + if (!(typeClassName == rhs.typeClassName)) + return false; + return true; + } + bool operator != (const TUserDefinedTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TUserDefinedTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TTypeEntry__isset { + _TTypeEntry__isset() : primitiveEntry(false), arrayEntry(false), mapEntry(false), structEntry(false), unionEntry(false), userDefinedTypeEntry(false) {} + bool primitiveEntry :1; + bool arrayEntry :1; + bool mapEntry :1; + bool structEntry :1; + bool unionEntry :1; + bool userDefinedTypeEntry :1; +} _TTypeEntry__isset; + +class TTypeEntry { + public: + + TTypeEntry(const TTypeEntry&); + TTypeEntry& operator=(const TTypeEntry&); + TTypeEntry() { + } + + virtual ~TTypeEntry() throw(); + TPrimitiveTypeEntry primitiveEntry; + TArrayTypeEntry arrayEntry; + TMapTypeEntry mapEntry; + TStructTypeEntry structEntry; + TUnionTypeEntry unionEntry; + TUserDefinedTypeEntry userDefinedTypeEntry; + + _TTypeEntry__isset __isset; + + void __set_primitiveEntry(const TPrimitiveTypeEntry& val); + + void __set_arrayEntry(const TArrayTypeEntry& val); + + void __set_mapEntry(const TMapTypeEntry& val); + + void __set_structEntry(const TStructTypeEntry& val); + + void __set_unionEntry(const TUnionTypeEntry& val); + + void __set_userDefinedTypeEntry(const TUserDefinedTypeEntry& val); + + bool operator == (const TTypeEntry & rhs) const + { + if (!(primitiveEntry == rhs.primitiveEntry)) + return false; + if (!(arrayEntry == rhs.arrayEntry)) + return false; + if (!(mapEntry == rhs.mapEntry)) + return false; + if (!(structEntry == rhs.structEntry)) + return false; + if (!(unionEntry == rhs.unionEntry)) + return false; + if (!(userDefinedTypeEntry == rhs.userDefinedTypeEntry)) + return false; + return true; + } + bool operator != (const TTypeEntry &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTypeEntry & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TTypeEntry &a, TTypeEntry &b); + +inline std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj) +{ + obj.printTo(out); + return out; +} + + +class TTypeDesc { + public: + + TTypeDesc(const TTypeDesc&); + TTypeDesc& operator=(const TTypeDesc&); + TTypeDesc() { + } + + virtual ~TTypeDesc() throw(); + std::vector<TTypeEntry> types; + + void __set_types(const std::vector<TTypeEntry> & val); + + bool operator == (const TTypeDesc & rhs) const + { + if (!(types == rhs.types)) + return false; + return true; + } + bool operator != (const TTypeDesc &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTypeDesc & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TTypeDesc &a, TTypeDesc &b); + +inline std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TColumnDesc__isset { + _TColumnDesc__isset() : comment(false) {} + bool comment :1; +} _TColumnDesc__isset; + +class TColumnDesc { + public: + + TColumnDesc(const TColumnDesc&); + TColumnDesc& operator=(const TColumnDesc&); + TColumnDesc() : columnName(), position(0), comment() { + } + + virtual ~TColumnDesc() throw(); + std::string columnName; + TTypeDesc typeDesc; + int32_t position; + std::string comment; + + _TColumnDesc__isset __isset; + + void __set_columnName(const std::string& val); + + void __set_typeDesc(const TTypeDesc& val); + + void __set_position(const int32_t val); + + void __set_comment(const std::string& val); + + bool operator == (const TColumnDesc & rhs) const + { + if (!(columnName == rhs.columnName)) + return false; + if (!(typeDesc == rhs.typeDesc)) + return false; + if (!(position == rhs.position)) + return false; + if (__isset.comment != rhs.__isset.comment) + return false; + else if (__isset.comment && !(comment == rhs.comment)) + return false; + return true; + } + bool operator != (const TColumnDesc &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TColumnDesc & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TColumnDesc &a, TColumnDesc &b); + +inline std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj) +{ + obj.printTo(out); + return out; +} + + +class TTableSchema { + public: + + TTableSchema(const TTableSchema&); + TTableSchema& operator=(const TTableSchema&); + TTableSchema() { + } + + virtual ~TTableSchema() throw(); + std::vector<TColumnDesc> columns; + + void __set_columns(const std::vector<TColumnDesc> & val); + + bool operator == (const TTableSchema & rhs) const + { + if (!(columns == rhs.columns)) + return false; + return true; + } + bool operator != (const TTableSchema &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TTableSchema & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TTableSchema &a, TTableSchema &b); + +inline std::ostream& operator<<(std::ostream& out, const TTableSchema& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TBoolValue__isset { + _TBoolValue__isset() : value(false) {} + bool value :1; +} _TBoolValue__isset; + +class TBoolValue { + public: + + TBoolValue(const TBoolValue&); + TBoolValue& operator=(const TBoolValue&); + TBoolValue() : value(0) { + } + + virtual ~TBoolValue() throw(); + bool value; + + _TBoolValue__isset __isset; + + void __set_value(const bool val); + + bool operator == (const TBoolValue & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TBoolValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TBoolValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TBoolValue &a, TBoolValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TBoolValue& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TByteValue__isset { + _TByteValue__isset() : value(false) {} + bool value :1; +} _TByteValue__isset; + +class TByteValue { + public: + + TByteValue(const TByteValue&); + TByteValue& operator=(const TByteValue&); + TByteValue() : value(0) { + } + + virtual ~TByteValue() throw(); + int8_t value; + + _TByteValue__isset __isset; + + void __set_value(const int8_t val); + + bool operator == (const TByteValue & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TByteValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TByteValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TByteValue &a, TByteValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TByteValue& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TI16Value__isset { + _TI16Value__isset() : value(false) {} + bool value :1; +} _TI16Value__isset; + +class TI16Value { + public: + + TI16Value(const TI16Value&); + TI16Value& operator=(const TI16Value&); + TI16Value() : value(0) { + } + + virtual ~TI16Value() throw(); + int16_t value; + + _TI16Value__isset __isset; + + void __set_value(const int16_t val); + + bool operator == (const TI16Value & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TI16Value &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TI16Value & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TI16Value &a, TI16Value &b); + +inline std::ostream& operator<<(std::ostream& out, const TI16Value& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TI32Value__isset { + _TI32Value__isset() : value(false) {} + bool value :1; +} _TI32Value__isset; + +class TI32Value { + public: + + TI32Value(const TI32Value&); + TI32Value& operator=(const TI32Value&); + TI32Value() : value(0) { + } + + virtual ~TI32Value() throw(); + int32_t value; + + _TI32Value__isset __isset; + + void __set_value(const int32_t val); + + bool operator == (const TI32Value & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TI32Value &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TI32Value & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TI32Value &a, TI32Value &b); + +inline std::ostream& operator<<(std::ostream& out, const TI32Value& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TI64Value__isset { + _TI64Value__isset() : value(false) {} + bool value :1; +} _TI64Value__isset; + +class TI64Value { + public: + + TI64Value(const TI64Value&); + TI64Value& operator=(const TI64Value&); + TI64Value() : value(0) { + } + + virtual ~TI64Value() throw(); + int64_t value; + + _TI64Value__isset __isset; + + void __set_value(const int64_t val); + + bool operator == (const TI64Value & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TI64Value &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TI64Value & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TI64Value &a, TI64Value &b); + +inline std::ostream& operator<<(std::ostream& out, const TI64Value& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TDoubleValue__isset { + _TDoubleValue__isset() : value(false) {} + bool value :1; +} _TDoubleValue__isset; + +class TDoubleValue { + public: + + TDoubleValue(const TDoubleValue&); + TDoubleValue& operator=(const TDoubleValue&); + TDoubleValue() : value(0) { + } + + virtual ~TDoubleValue() throw(); + double value; + + _TDoubleValue__isset __isset; + + void __set_value(const double val); + + bool operator == (const TDoubleValue & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TDoubleValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TDoubleValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TDoubleValue &a, TDoubleValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TStringValue__isset { + _TStringValue__isset() : value(false) {} + bool value :1; +} _TStringValue__isset; + +class TStringValue { + public: + + TStringValue(const TStringValue&); + TStringValue& operator=(const TStringValue&); + TStringValue() : value() { + } + + virtual ~TStringValue() throw(); + std::string value; + + _TStringValue__isset __isset; + + void __set_value(const std::string& val); + + bool operator == (const TStringValue & rhs) const + { + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + return true; + } + bool operator != (const TStringValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TStringValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TStringValue &a, TStringValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TStringValue& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TColumnValue__isset { + _TColumnValue__isset() : boolVal(false), byteVal(false), i16Val(false), i32Val(false), i64Val(false), doubleVal(false), stringVal(false) {} + bool boolVal :1; + bool byteVal :1; + bool i16Val :1; + bool i32Val :1; + bool i64Val :1; + bool doubleVal :1; + bool stringVal :1; +} _TColumnValue__isset; + +class TColumnValue { + public: + + TColumnValue(const TColumnValue&); + TColumnValue& operator=(const TColumnValue&); + TColumnValue() { + } + + virtual ~TColumnValue() throw(); + TBoolValue boolVal; + TByteValue byteVal; + TI16Value i16Val; + TI32Value i32Val; + TI64Value i64Val; + TDoubleValue doubleVal; + TStringValue stringVal; + + _TColumnValue__isset __isset; + + void __set_boolVal(const TBoolValue& val); + + void __set_byteVal(const TByteValue& val); + + void __set_i16Val(const TI16Value& val); + + void __set_i32Val(const TI32Value& val); + + void __set_i64Val(const TI64Value& val); + + void __set_doubleVal(const TDoubleValue& val); + + void __set_stringVal(const TStringValue& val); + + bool operator == (const TColumnValue & rhs) const + { + if (!(boolVal == rhs.boolVal)) + return false; + if (!(byteVal == rhs.byteVal)) + return false; + if (!(i16Val == rhs.i16Val)) + return false; + if (!(i32Val == rhs.i32Val)) + return false; + if (!(i64Val == rhs.i64Val)) + return false; + if (!(doubleVal == rhs.doubleVal)) + return false; + if (!(stringVal == rhs.stringVal)) + return false; + return true; + } + bool operator != (const TColumnValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TColumnValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TColumnValue &a, TColumnValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TColumnValue& obj) +{ + obj.printTo(out); + return out; +} + + +class TRow { + public: + + TRow(const TRow&); + TRow& operator=(const TRow&); + TRow() { + } + + virtual ~TRow() throw(); + std::vector<TColumnValue> colVals; + + void __set_colVals(const std::vector<TColumnValue> & val); + + bool operator == (const TRow & rhs) const + { + if (!(colVals == rhs.colVals)) + return false; + return true; + } + bool operator != (const TRow &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TRow & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TRow &a, TRow &b); + +inline std::ostream& operator<<(std::ostream& out, const TRow& obj) +{ + obj.printTo(out); + return out; +} + + +class TBoolColumn { + public: + + TBoolColumn(const TBoolColumn&); + TBoolColumn& operator=(const TBoolColumn&); + TBoolColumn() : nulls() { + } + + virtual ~TBoolColumn() throw(); + std::vector<bool> values; + std::string nulls; + + void __set_values(const std::vector<bool> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TBoolColumn & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TBoolColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TBoolColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TBoolColumn &a, TBoolColumn &b); + +inline std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj) +{ + obj.printTo(out); + return out; +} + + +class TByteColumn { + public: + + TByteColumn(const TByteColumn&); + TByteColumn& operator=(const TByteColumn&); + TByteColumn() : nulls() { + } + + virtual ~TByteColumn() throw(); + std::vector<int8_t> values; + std::string nulls; + + void __set_values(const std::vector<int8_t> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TByteColumn & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TByteColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TByteColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TByteColumn &a, TByteColumn &b); + +inline std::ostream& operator<<(std::ostream& out, const TByteColumn& obj) +{ + obj.printTo(out); + return out; +} + + +class TI16Column { + public: + + TI16Column(const TI16Column&); + TI16Column& operator=(const TI16Column&); + TI16Column() : nulls() { + } + + virtual ~TI16Column() throw(); + std::vector<int16_t> values; + std::string nulls; + + void __set_values(const std::vector<int16_t> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TI16Column & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TI16Column &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TI16Column & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TI16Column &a, TI16Column &b); + +inline std::ostream& operator<<(std::ostream& out, const TI16Column& obj) +{ + obj.printTo(out); + return out; +} + + +class TI32Column { + public: + + TI32Column(const TI32Column&); + TI32Column& operator=(const TI32Column&); + TI32Column() : nulls() { + } + + virtual ~TI32Column() throw(); + std::vector<int32_t> values; + std::string nulls; + + void __set_values(const std::vector<int32_t> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TI32Column & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TI32Column &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TI32Column & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TI32Column &a, TI32Column &b); + +inline std::ostream& operator<<(std::ostream& out, const TI32Column& obj) +{ + obj.printTo(out); + return out; +} + + +class TI64Column { + public: + + TI64Column(const TI64Column&); + TI64Column& operator=(const TI64Column&); + TI64Column() : nulls() { + } + + virtual ~TI64Column() throw(); + std::vector<int64_t> values; + std::string nulls; + + void __set_values(const std::vector<int64_t> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TI64Column & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TI64Column &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TI64Column & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TI64Column &a, TI64Column &b); + +inline std::ostream& operator<<(std::ostream& out, const TI64Column& obj) +{ + obj.printTo(out); + return out; +} + + +class TDoubleColumn { + public: + + TDoubleColumn(const TDoubleColumn&); + TDoubleColumn& operator=(const TDoubleColumn&); + TDoubleColumn() : nulls() { + } + + virtual ~TDoubleColumn() throw(); + std::vector<double> values; + std::string nulls; + + void __set_values(const std::vector<double> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TDoubleColumn & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TDoubleColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TDoubleColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TDoubleColumn &a, TDoubleColumn &b); + +inline std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj) +{ + obj.printTo(out); + return out; +} + + +class TStringColumn { + public: + + TStringColumn(const TStringColumn&); + TStringColumn& operator=(const TStringColumn&); + TStringColumn() : nulls() { + } + + virtual ~TStringColumn() throw(); + std::vector<std::string> values; + std::string nulls; + + void __set_values(const std::vector<std::string> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TStringColumn & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TStringColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TStringColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TStringColumn &a, TStringColumn &b); + +inline std::ostream& operator<<(std::ostream& out, const TStringColumn& obj) +{ + obj.printTo(out); + return out; +} + + +class TBinaryColumn { + public: + + TBinaryColumn(const TBinaryColumn&); + TBinaryColumn& operator=(const TBinaryColumn&); + TBinaryColumn() : nulls() { + } + + virtual ~TBinaryColumn() throw(); + std::vector<std::string> values; + std::string nulls; + + void __set_values(const std::vector<std::string> & val); + + void __set_nulls(const std::string& val); + + bool operator == (const TBinaryColumn & rhs) const + { + if (!(values == rhs.values)) + return false; + if (!(nulls == rhs.nulls)) + return false; + return true; + } + bool operator != (const TBinaryColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TBinaryColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TBinaryColumn &a, TBinaryColumn &b); + +inline std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TColumn__isset { + _TColumn__isset() : boolVal(false), byteVal(false), i16Val(false), i32Val(false), i64Val(false), doubleVal(false), stringVal(false), binaryVal(false) {} + bool boolVal :1; + bool byteVal :1; + bool i16Val :1; + bool i32Val :1; + bool i64Val :1; + bool doubleVal :1; + bool stringVal :1; + bool binaryVal :1; +} _TColumn__isset; + +class TColumn { + public: + + TColumn(const TColumn&); + TColumn& operator=(const TColumn&); + TColumn() { + } + + virtual ~TColumn() throw(); + TBoolColumn boolVal; + TByteColumn byteVal; + TI16Column i16Val; + TI32Column i32Val; + TI64Column i64Val; + TDoubleColumn doubleVal; + TStringColumn stringVal; + TBinaryColumn binaryVal; + + _TColumn__isset __isset; + + void __set_boolVal(const TBoolColumn& val); + + void __set_byteVal(const TByteColumn& val); + + void __set_i16Val(const TI16Column& val); + + void __set_i32Val(const TI32Column& val); + + void __set_i64Val(const TI64Column& val); + + void __set_doubleVal(const TDoubleColumn& val); + + void __set_stringVal(const TStringColumn& val); + + void __set_binaryVal(const TBinaryColumn& val); + + bool operator == (const TColumn & rhs) const + { + if (!(boolVal == rhs.boolVal)) + return false; + if (!(byteVal == rhs.byteVal)) + return false; + if (!(i16Val == rhs.i16Val)) + return false; + if (!(i32Val == rhs.i32Val)) + return false; + if (!(i64Val == rhs.i64Val)) + return false; + if (!(doubleVal == rhs.doubleVal)) + return false; + if (!(stringVal == rhs.stringVal)) + return false; + if (!(binaryVal == rhs.binaryVal)) + return false; + return true; + } + bool operator != (const TColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TColumn &a, TColumn &b); + +inline std::ostream& operator<<(std::ostream& out, const TColumn& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TRowSet__isset { + _TRowSet__isset() : columns(false) {} + bool columns :1; +} _TRowSet__isset; + +class TRowSet { + public: + + TRowSet(const TRowSet&); + TRowSet& operator=(const TRowSet&); + TRowSet() : startRowOffset(0) { + } + + virtual ~TRowSet() throw(); + int64_t startRowOffset; + std::vector<TRow> rows; + std::vector<TColumn> columns; + + _TRowSet__isset __isset; + + void __set_startRowOffset(const int64_t val); + + void __set_rows(const std::vector<TRow> & val); + + void __set_columns(const std::vector<TColumn> & val); + + bool operator == (const TRowSet & rhs) const + { + if (!(startRowOffset == rhs.startRowOffset)) + return false; + if (!(rows == rhs.rows)) + return false; + if (__isset.columns != rhs.__isset.columns) + return false; + else if (__isset.columns && !(columns == rhs.columns)) + return false; + return true; + } + bool operator != (const TRowSet &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TRowSet & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TRowSet &a, TRowSet &b); + +inline std::ostream& operator<<(std::ostream& out, const TRowSet& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TStatus__isset { + _TStatus__isset() : infoMessages(false), sqlState(false), errorCode(false), errorMessage(false) {} + bool infoMessages :1; + bool sqlState :1; + bool errorCode :1; + bool errorMessage :1; +} _TStatus__isset; + +class TStatus { + public: + + TStatus(const TStatus&); + TStatus& operator=(const TStatus&); + TStatus() : statusCode((TStatusCode::type)0), sqlState(), errorCode(0), errorMessage() { + } + + virtual ~TStatus() throw(); + TStatusCode::type statusCode; + std::vector<std::string> infoMessages; + std::string sqlState; + int32_t errorCode; + std::string errorMessage; + + _TStatus__isset __isset; + + void __set_statusCode(const TStatusCode::type val); + + void __set_infoMessages(const std::vector<std::string> & val); + + void __set_sqlState(const std::string& val); + + void __set_errorCode(const int32_t val); + + void __set_errorMessage(const std::string& val); + + bool operator == (const TStatus & rhs) const + { + if (!(statusCode == rhs.statusCode)) + return false; + if (__isset.infoMessages != rhs.__isset.infoMessages) + return false; + else if (__isset.infoMessages && !(infoMessages == rhs.infoMessages)) + return false; + if (__isset.sqlState != rhs.__isset.sqlState) + return false; + else if (__isset.sqlState && !(sqlState == rhs.sqlState)) + return false; + if (__isset.errorCode != rhs.__isset.errorCode) + return false; + else if (__isset.errorCode && !(errorCode == rhs.errorCode)) + return false; + if (__isset.errorMessage != rhs.__isset.errorMessage) + return false; + else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage)) + return false; + return true; + } + bool operator != (const TStatus &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TStatus & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TStatus &a, TStatus &b); + +inline std::ostream& operator<<(std::ostream& out, const TStatus& obj) +{ + obj.printTo(out); + return out; +} + + +class THandleIdentifier { + public: + + THandleIdentifier(const THandleIdentifier&); + THandleIdentifier& operator=(const THandleIdentifier&); + THandleIdentifier() : guid(), secret() { + } + + virtual ~THandleIdentifier() throw(); + std::string guid; + std::string secret; + + void __set_guid(const std::string& val); + + void __set_secret(const std::string& val); + + bool operator == (const THandleIdentifier & rhs) const + { + if (!(guid == rhs.guid)) + return false; + if (!(secret == rhs.secret)) + return false; + return true; + } + bool operator != (const THandleIdentifier &rhs) const { + return !(*this == rhs); + } + + bool operator < (const THandleIdentifier & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(THandleIdentifier &a, THandleIdentifier &b); + +inline std::ostream& operator<<(std::ostream& out, const THandleIdentifier& obj) +{ + obj.printTo(out); + return out; +} + + +class TSessionHandle { + public: + + TSessionHandle(const TSessionHandle&); + TSessionHandle& operator=(const TSessionHandle&); + TSessionHandle() { + } + + virtual ~TSessionHandle() throw(); + THandleIdentifier sessionId; + + void __set_sessionId(const THandleIdentifier& val); + + bool operator == (const TSessionHandle & rhs) const + { + if (!(sessionId == rhs.sessionId)) + return false; + return true; + } + bool operator != (const TSessionHandle &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TSessionHandle & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TSessionHandle &a, TSessionHandle &b); + +inline std::ostream& operator<<(std::ostream& out, const TSessionHandle& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TOperationHandle__isset { + _TOperationHandle__isset() : modifiedRowCount(false) {} + bool modifiedRowCount :1; +} _TOperationHandle__isset; + +class TOperationHandle { + public: + + TOperationHandle(const TOperationHandle&); + TOperationHandle& operator=(const TOperationHandle&); + TOperationHandle() : operationType((TOperationType::type)0), hasResultSet(0), modifiedRowCount(0) { + } + + virtual ~TOperationHandle() throw(); + THandleIdentifier operationId; + TOperationType::type operationType; + bool hasResultSet; + double modifiedRowCount; + + _TOperationHandle__isset __isset; + + void __set_operationId(const THandleIdentifier& val); + + void __set_operationType(const TOperationType::type val); + + void __set_hasResultSet(const bool val); + + void __set_modifiedRowCount(const double val); + + bool operator == (const TOperationHandle & rhs) const + { + if (!(operationId == rhs.operationId)) + return false; + if (!(operationType == rhs.operationType)) + return false; + if (!(hasResultSet == rhs.hasResultSet)) + return false; + if (__isset.modifiedRowCount != rhs.__isset.modifiedRowCount) + return false; + else if (__isset.modifiedRowCount && !(modifiedRowCount == rhs.modifiedRowCount)) + return false; + return true; + } + bool operator != (const TOperationHandle &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TOperationHandle & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TOperationHandle &a, TOperationHandle &b); + +inline std::ostream& operator<<(std::ostream& out, const TOperationHandle& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TOpenSessionReq__isset { + _TOpenSessionReq__isset() : username(false), password(false), configuration(false) {} + bool username :1; + bool password :1; + bool configuration :1; +} _TOpenSessionReq__isset; + +class TOpenSessionReq { + public: + + TOpenSessionReq(const TOpenSessionReq&); + TOpenSessionReq& operator=(const TOpenSessionReq&); + TOpenSessionReq() : client_protocol((TProtocolVersion::type)7), username(), password() { + client_protocol = (TProtocolVersion::type)7; + + } + + virtual ~TOpenSessionReq() throw(); + TProtocolVersion::type client_protocol; + std::string username; + std::string password; + std::map<std::string, std::string> configuration; + + _TOpenSessionReq__isset __isset; + + void __set_client_protocol(const TProtocolVersion::type val); + + void __set_username(const std::string& val); + + void __set_password(const std::string& val); + + void __set_configuration(const std::map<std::string, std::string> & val); + + bool operator == (const TOpenSessionReq & rhs) const + { + if (!(client_protocol == rhs.client_protocol)) + return false; + if (__isset.username != rhs.__isset.username) + return false; + else if (__isset.username && !(username == rhs.username)) + return false; + if (__isset.password != rhs.__isset.password) + return false; + else if (__isset.password && !(password == rhs.password)) + return false; + if (__isset.configuration != rhs.__isset.configuration) + return false; + else if (__isset.configuration && !(configuration == rhs.configuration)) + return false; + return true; + } + bool operator != (const TOpenSessionReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TOpenSessionReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TOpenSessionReq &a, TOpenSessionReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TOpenSessionReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TOpenSessionResp__isset { + _TOpenSessionResp__isset() : sessionHandle(false), configuration(false) {} + bool sessionHandle :1; + bool configuration :1; +} _TOpenSessionResp__isset; + +class TOpenSessionResp { + public: + + TOpenSessionResp(const TOpenSessionResp&); + TOpenSessionResp& operator=(const TOpenSessionResp&); + TOpenSessionResp() : serverProtocolVersion((TProtocolVersion::type)7) { + serverProtocolVersion = (TProtocolVersion::type)7; + + } + + virtual ~TOpenSessionResp() throw(); + TStatus status; + TProtocolVersion::type serverProtocolVersion; + TSessionHandle sessionHandle; + std::map<std::string, std::string> configuration; + + _TOpenSessionResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_serverProtocolVersion(const TProtocolVersion::type val); + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_configuration(const std::map<std::string, std::string> & val); + + bool operator == (const TOpenSessionResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (!(serverProtocolVersion == rhs.serverProtocolVersion)) + return false; + if (__isset.sessionHandle != rhs.__isset.sessionHandle) + return false; + else if (__isset.sessionHandle && !(sessionHandle == rhs.sessionHandle)) + return false; + if (__isset.configuration != rhs.__isset.configuration) + return false; + else if (__isset.configuration && !(configuration == rhs.configuration)) + return false; + return true; + } + bool operator != (const TOpenSessionResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TOpenSessionResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TOpenSessionResp &a, TOpenSessionResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TOpenSessionResp& obj) +{ + obj.printTo(out); + return out; +} + + +class TCloseSessionReq { + public: + + TCloseSessionReq(const TCloseSessionReq&); + TCloseSessionReq& operator=(const TCloseSessionReq&); + TCloseSessionReq() { + } + + virtual ~TCloseSessionReq() throw(); + TSessionHandle sessionHandle; + + void __set_sessionHandle(const TSessionHandle& val); + + bool operator == (const TCloseSessionReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + return true; + } + bool operator != (const TCloseSessionReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCloseSessionReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TCloseSessionReq &a, TCloseSessionReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TCloseSessionReq& obj) +{ + obj.printTo(out); + return out; +} + + +class TCloseSessionResp { + public: + + TCloseSessionResp(const TCloseSessionResp&); + TCloseSessionResp& operator=(const TCloseSessionResp&); + TCloseSessionResp() { + } + + virtual ~TCloseSessionResp() throw(); + TStatus status; + + void __set_status(const TStatus& val); + + bool operator == (const TCloseSessionResp & rhs) const + { + if (!(status == rhs.status)) + return false; + return true; + } + bool operator != (const TCloseSessionResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TCloseSessionResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TCloseSessionResp &a, TCloseSessionResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TCloseSessionResp& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetInfoValue__isset { + _TGetInfoValue__isset() : stringValue(false), smallIntValue(false), integerBitmask(false), integerFlag(false), binaryValue(false), lenValue(false) {} + bool stringValue :1; + bool smallIntValue :1; + bool integerBitmask :1; + bool integerFlag :1; + bool binaryValue :1; + bool lenValue :1; +} _TGetInfoValue__isset; + +class TGetInfoValue { + public: + + TGetInfoValue(const TGetInfoValue&); + TGetInfoValue& operator=(const TGetInfoValue&); + TGetInfoValue() : stringValue(), smallIntValue(0), integerBitmask(0), integerFlag(0), binaryValue(0), lenValue(0) { + } + + virtual ~TGetInfoValue() throw(); + std::string stringValue; + int16_t smallIntValue; + int32_t integerBitmask; + int32_t integerFlag; + int32_t binaryValue; + int64_t lenValue; + + _TGetInfoValue__isset __isset; + + void __set_stringValue(const std::string& val); + + void __set_smallIntValue(const int16_t val); + + void __set_integerBitmask(const int32_t val); + + void __set_integerFlag(const int32_t val); + + void __set_binaryValue(const int32_t val); + + void __set_lenValue(const int64_t val); + + bool operator == (const TGetInfoValue & rhs) const + { + if (!(stringValue == rhs.stringValue)) + return false; + if (!(smallIntValue == rhs.smallIntValue)) + return false; + if (!(integerBitmask == rhs.integerBitmask)) + return false; + if (!(integerFlag == rhs.integerFlag)) + return false; + if (!(binaryValue == rhs.binaryValue)) + return false; + if (!(lenValue == rhs.lenValue)) + return false; + return true; + } + bool operator != (const TGetInfoValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetInfoValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetInfoValue &a, TGetInfoValue &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetInfoValue& obj) +{ + obj.printTo(out); + return out; +} + + +class TGetInfoReq { + public: + + TGetInfoReq(const TGetInfoReq&); + TGetInfoReq& operator=(const TGetInfoReq&); + TGetInfoReq() : infoType((TGetInfoType::type)0) { + } + + virtual ~TGetInfoReq() throw(); + TSessionHandle sessionHandle; + TGetInfoType::type infoType; + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_infoType(const TGetInfoType::type val); + + bool operator == (const TGetInfoReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + if (!(infoType == rhs.infoType)) + return false; + return true; + } + bool operator != (const TGetInfoReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetInfoReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetInfoReq &a, TGetInfoReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetInfoReq& obj) +{ + obj.printTo(out); + return out; +} + + +class TGetInfoResp { + public: + + TGetInfoResp(const TGetInfoResp&); + TGetInfoResp& operator=(const TGetInfoResp&); + TGetInfoResp() { + } + + virtual ~TGetInfoResp() throw(); + TStatus status; + TGetInfoValue infoValue; + + void __set_status(const TStatus& val); + + void __set_infoValue(const TGetInfoValue& val); + + bool operator == (const TGetInfoResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (!(infoValue == rhs.infoValue)) + return false; + return true; + } + bool operator != (const TGetInfoResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetInfoResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetInfoResp &a, TGetInfoResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetInfoResp& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TExecuteStatementReq__isset { + _TExecuteStatementReq__isset() : confOverlay(false), runAsync(true) {} + bool confOverlay :1; + bool runAsync :1; +} _TExecuteStatementReq__isset; + +class TExecuteStatementReq { + public: + + TExecuteStatementReq(const TExecuteStatementReq&); + TExecuteStatementReq& operator=(const TExecuteStatementReq&); + TExecuteStatementReq() : statement(), runAsync(false) { + } + + virtual ~TExecuteStatementReq() throw(); + TSessionHandle sessionHandle; + std::string statement; + std::map<std::string, std::string> confOverlay; + bool runAsync; + + _TExecuteStatementReq__isset __isset; + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_statement(const std::string& val); + + void __set_confOverlay(const std::map<std::string, std::string> & val); + + void __set_runAsync(const bool val); + + bool operator == (const TExecuteStatementReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + if (!(statement == rhs.statement)) + return false; + if (__isset.confOverlay != rhs.__isset.confOverlay) + return false; + else if (__isset.confOverlay && !(confOverlay == rhs.confOverlay)) + return false; + if (__isset.runAsync != rhs.__isset.runAsync) + return false; + else if (__isset.runAsync && !(runAsync == rhs.runAsync)) + return false; + return true; + } + bool operator != (const TExecuteStatementReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TExecuteStatementReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TExecuteStatementReq &a, TExecuteStatementReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TExecuteStatementReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TExecuteStatementResp__isset { + _TExecuteStatementResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TExecuteStatementResp__isset; + +class TExecuteStatementResp { + public: + + TExecuteStatementResp(const TExecuteStatementResp&); + TExecuteStatementResp& operator=(const TExecuteStatementResp&); + TExecuteStatementResp() { + } + + virtual ~TExecuteStatementResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TExecuteStatementResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TExecuteStatementResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TExecuteStatementResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TExecuteStatementResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TExecuteStatementResp &a, TExecuteStatementResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TExecuteStatementResp& obj) +{ + obj.printTo(out); + return out; +} + + +class TGetTypeInfoReq { + public: + + TGetTypeInfoReq(const TGetTypeInfoReq&); + TGetTypeInfoReq& operator=(const TGetTypeInfoReq&); + TGetTypeInfoReq() { + } + + virtual ~TGetTypeInfoReq() throw(); + TSessionHandle sessionHandle; + + void __set_sessionHandle(const TSessionHandle& val); + + bool operator == (const TGetTypeInfoReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + return true; + } + bool operator != (const TGetTypeInfoReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetTypeInfoReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetTypeInfoReq &a, TGetTypeInfoReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetTypeInfoReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetTypeInfoResp__isset { + _TGetTypeInfoResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetTypeInfoResp__isset; + +class TGetTypeInfoResp { + public: + + TGetTypeInfoResp(const TGetTypeInfoResp&); + TGetTypeInfoResp& operator=(const TGetTypeInfoResp&); + TGetTypeInfoResp() { + } + + virtual ~TGetTypeInfoResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetTypeInfoResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetTypeInfoResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetTypeInfoResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetTypeInfoResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetTypeInfoResp &a, TGetTypeInfoResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetTypeInfoResp& obj) +{ + obj.printTo(out); + return out; +} + + +class TGetCatalogsReq { + public: + + TGetCatalogsReq(const TGetCatalogsReq&); + TGetCatalogsReq& operator=(const TGetCatalogsReq&); + TGetCatalogsReq() { + } + + virtual ~TGetCatalogsReq() throw(); + TSessionHandle sessionHandle; + + void __set_sessionHandle(const TSessionHandle& val); + + bool operator == (const TGetCatalogsReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + return true; + } + bool operator != (const TGetCatalogsReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetCatalogsReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetCatalogsReq &a, TGetCatalogsReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetCatalogsReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetCatalogsResp__isset { + _TGetCatalogsResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetCatalogsResp__isset; + +class TGetCatalogsResp { + public: + + TGetCatalogsResp(const TGetCatalogsResp&); + TGetCatalogsResp& operator=(const TGetCatalogsResp&); + TGetCatalogsResp() { + } + + virtual ~TGetCatalogsResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetCatalogsResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetCatalogsResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetCatalogsResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetCatalogsResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetCatalogsResp &a, TGetCatalogsResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetCatalogsResp& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetSchemasReq__isset { + _TGetSchemasReq__isset() : catalogName(false), schemaName(false) {} + bool catalogName :1; + bool schemaName :1; +} _TGetSchemasReq__isset; + +class TGetSchemasReq { + public: + + TGetSchemasReq(const TGetSchemasReq&); + TGetSchemasReq& operator=(const TGetSchemasReq&); + TGetSchemasReq() : catalogName(), schemaName() { + } + + virtual ~TGetSchemasReq() throw(); + TSessionHandle sessionHandle; + TIdentifier catalogName; + TPatternOrIdentifier schemaName; + + _TGetSchemasReq__isset __isset; + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_catalogName(const TIdentifier& val); + + void __set_schemaName(const TPatternOrIdentifier& val); + + bool operator == (const TGetSchemasReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.schemaName != rhs.__isset.schemaName) + return false; + else if (__isset.schemaName && !(schemaName == rhs.schemaName)) + return false; + return true; + } + bool operator != (const TGetSchemasReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetSchemasReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetSchemasReq &a, TGetSchemasReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetSchemasReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetSchemasResp__isset { + _TGetSchemasResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetSchemasResp__isset; + +class TGetSchemasResp { + public: + + TGetSchemasResp(const TGetSchemasResp&); + TGetSchemasResp& operator=(const TGetSchemasResp&); + TGetSchemasResp() { + } + + virtual ~TGetSchemasResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetSchemasResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetSchemasResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetSchemasResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetSchemasResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetSchemasResp &a, TGetSchemasResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetSchemasResp& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetTablesReq__isset { + _TGetTablesReq__isset() : catalogName(false), schemaName(false), tableName(false), tableTypes(false) {} + bool catalogName :1; + bool schemaName :1; + bool tableName :1; + bool tableTypes :1; +} _TGetTablesReq__isset; + +class TGetTablesReq { + public: + + TGetTablesReq(const TGetTablesReq&); + TGetTablesReq& operator=(const TGetTablesReq&); + TGetTablesReq() : catalogName(), schemaName(), tableName() { + } + + virtual ~TGetTablesReq() throw(); + TSessionHandle sessionHandle; + TPatternOrIdentifier catalogName; + TPatternOrIdentifier schemaName; + TPatternOrIdentifier tableName; + std::vector<std::string> tableTypes; + + _TGetTablesReq__isset __isset; + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_catalogName(const TPatternOrIdentifier& val); + + void __set_schemaName(const TPatternOrIdentifier& val); + + void __set_tableName(const TPatternOrIdentifier& val); + + void __set_tableTypes(const std::vector<std::string> & val); + + bool operator == (const TGetTablesReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.schemaName != rhs.__isset.schemaName) + return false; + else if (__isset.schemaName && !(schemaName == rhs.schemaName)) + return false; + if (__isset.tableName != rhs.__isset.tableName) + return false; + else if (__isset.tableName && !(tableName == rhs.tableName)) + return false; + if (__isset.tableTypes != rhs.__isset.tableTypes) + return false; + else if (__isset.tableTypes && !(tableTypes == rhs.tableTypes)) + return false; + return true; + } + bool operator != (const TGetTablesReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetTablesReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetTablesReq &a, TGetTablesReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetTablesReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetTablesResp__isset { + _TGetTablesResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetTablesResp__isset; + +class TGetTablesResp { + public: + + TGetTablesResp(const TGetTablesResp&); + TGetTablesResp& operator=(const TGetTablesResp&); + TGetTablesResp() { + } + + virtual ~TGetTablesResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetTablesResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetTablesResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetTablesResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetTablesResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetTablesResp &a, TGetTablesResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetTablesResp& obj) +{ + obj.printTo(out); + return out; +} + + +class TGetTableTypesReq { + public: + + TGetTableTypesReq(const TGetTableTypesReq&); + TGetTableTypesReq& operator=(const TGetTableTypesReq&); + TGetTableTypesReq() { + } + + virtual ~TGetTableTypesReq() throw(); + TSessionHandle sessionHandle; + + void __set_sessionHandle(const TSessionHandle& val); + + bool operator == (const TGetTableTypesReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + return true; + } + bool operator != (const TGetTableTypesReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetTableTypesReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetTableTypesReq &a, TGetTableTypesReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetTableTypesReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetTableTypesResp__isset { + _TGetTableTypesResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetTableTypesResp__isset; + +class TGetTableTypesResp { + public: + + TGetTableTypesResp(const TGetTableTypesResp&); + TGetTableTypesResp& operator=(const TGetTableTypesResp&); + TGetTableTypesResp() { + } + + virtual ~TGetTableTypesResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetTableTypesResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetTableTypesResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetTableTypesResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetTableTypesResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetTableTypesResp &a, TGetTableTypesResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetTableTypesResp& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetColumnsReq__isset { + _TGetColumnsReq__isset() : catalogName(false), schemaName(false), tableName(false), columnName(false) {} + bool catalogName :1; + bool schemaName :1; + bool tableName :1; + bool columnName :1; +} _TGetColumnsReq__isset; + +class TGetColumnsReq { + public: + + TGetColumnsReq(const TGetColumnsReq&); + TGetColumnsReq& operator=(const TGetColumnsReq&); + TGetColumnsReq() : catalogName(), schemaName(), tableName(), columnName() { + } + + virtual ~TGetColumnsReq() throw(); + TSessionHandle sessionHandle; + TIdentifier catalogName; + TPatternOrIdentifier schemaName; + TPatternOrIdentifier tableName; + TPatternOrIdentifier columnName; + + _TGetColumnsReq__isset __isset; + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_catalogName(const TIdentifier& val); + + void __set_schemaName(const TPatternOrIdentifier& val); + + void __set_tableName(const TPatternOrIdentifier& val); + + void __set_columnName(const TPatternOrIdentifier& val); + + bool operator == (const TGetColumnsReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.schemaName != rhs.__isset.schemaName) + return false; + else if (__isset.schemaName && !(schemaName == rhs.schemaName)) + return false; + if (__isset.tableName != rhs.__isset.tableName) + return false; + else if (__isset.tableName && !(tableName == rhs.tableName)) + return false; + if (__isset.columnName != rhs.__isset.columnName) + return false; + else if (__isset.columnName && !(columnName == rhs.columnName)) + return false; + return true; + } + bool operator != (const TGetColumnsReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetColumnsReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetColumnsReq &a, TGetColumnsReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetColumnsReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetColumnsResp__isset { + _TGetColumnsResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetColumnsResp__isset; + +class TGetColumnsResp { + public: + + TGetColumnsResp(const TGetColumnsResp&); + TGetColumnsResp& operator=(const TGetColumnsResp&); + TGetColumnsResp() { + } + + virtual ~TGetColumnsResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetColumnsResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetColumnsResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetColumnsResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetColumnsResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetColumnsResp &a, TGetColumnsResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetColumnsResp& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetFunctionsReq__isset { + _TGetFunctionsReq__isset() : catalogName(false), schemaName(false) {} + bool catalogName :1; + bool schemaName :1; +} _TGetFunctionsReq__isset; + +class TGetFunctionsReq { + public: + + TGetFunctionsReq(const TGetFunctionsReq&); + TGetFunctionsReq& operator=(const TGetFunctionsReq&); + TGetFunctionsReq() : catalogName(), schemaName(), functionName() { + } + + virtual ~TGetFunctionsReq() throw(); + TSessionHandle sessionHandle; + TIdentifier catalogName; + TPatternOrIdentifier schemaName; + TPatternOrIdentifier functionName; + + _TGetFunctionsReq__isset __isset; + + void __set_sessionHandle(const TSessionHandle& val); + + void __set_catalogName(const TIdentifier& val); + + void __set_schemaName(const TPatternOrIdentifier& val); + + void __set_functionName(const TPatternOrIdentifier& val); + + bool operator == (const TGetFunctionsReq & rhs) const + { + if (!(sessionHandle == rhs.sessionHandle)) + return false; + if (__isset.catalogName != rhs.__isset.catalogName) + return false; + else if (__isset.catalogName && !(catalogName == rhs.catalogName)) + return false; + if (__isset.schemaName != rhs.__isset.schemaName) + return false; + else if (__isset.schemaName && !(schemaName == rhs.schemaName)) + return false; + if (!(functionName == rhs.functionName)) + return false; + return true; + } + bool operator != (const TGetFunctionsReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetFunctionsReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetFunctionsReq &a, TGetFunctionsReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetFunctionsReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetFunctionsResp__isset { + _TGetFunctionsResp__isset() : operationHandle(false) {} + bool operationHandle :1; +} _TGetFunctionsResp__isset; + +class TGetFunctionsResp { + public: + + TGetFunctionsResp(const TGetFunctionsResp&); + TGetFunctionsResp& operator=(const TGetFunctionsResp&); + TGetFunctionsResp() { + } + + virtual ~TGetFunctionsResp() throw(); + TStatus status; + TOperationHandle operationHandle; + + _TGetFunctionsResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetFunctionsResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationHandle != rhs.__isset.operationHandle) + return false; + else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetFunctionsResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetFunctionsResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetFunctionsResp &a, TGetFunctionsResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetFunctionsResp& obj) +{ + obj.printTo(out); + return out; +} + + +class TGetOperationStatusReq { + public: + + TGetOperationStatusReq(const TGetOperationStatusReq&); + TGetOperationStatusReq& operator=(const TGetOperationStatusReq&); + TGetOperationStatusReq() { + } + + virtual ~TGetOperationStatusReq() throw(); + TOperationHandle operationHandle; + + void __set_operationHandle(const TOperationHandle& val); + + bool operator == (const TGetOperationStatusReq & rhs) const + { + if (!(operationHandle == rhs.operationHandle)) + return false; + return true; + } + bool operator != (const TGetOperationStatusReq &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetOperationStatusReq & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetOperationStatusReq &a, TGetOperationStatusReq &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetOperationStatusReq& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _TGetOperationStatusResp__isset { + _TGetOperationStatusResp__isset() : operationState(false), sqlState(false), errorCode(false), errorMessage(false) {} + bool operationState :1; + bool sqlState :1; + bool errorCode :1; + bool errorMessage :1; +} _TGetOperationStatusResp__isset; + +class TGetOperationStatusResp { + public: + + TGetOperationStatusResp(const TGetOperationStatusResp&); + TGetOperationStatusResp& operator=(const TGetOperationStatusResp&); + TGetOperationStatusResp() : operationState((TOperationState::type)0), sqlState(), errorCode(0), errorMessage() { + } + + virtual ~TGetOperationStatusResp() throw(); + TStatus status; + TOperationState::type operationState; + std::string sqlState; + int32_t errorCode; + std::string errorMessage; + + _TGetOperationStatusResp__isset __isset; + + void __set_status(const TStatus& val); + + void __set_operationState(const TOperationState::type val); + + void __set_sqlState(const std::string& val); + + void __set_errorCode(const int32_t val); + + void __set_errorMessage(const std::string& val); + + bool operator == (const TGetOperationStatusResp & rhs) const + { + if (!(status == rhs.status)) + return false; + if (__isset.operationState != rhs.__isset.operationState) + return false; + else if (__isset.operationState && !(operationState == rhs.operationState)) + return false; + if (__isset.sqlState != rhs.__isset.sqlState) + return false; + else if (__isset.sqlState && !(sqlState == rhs.sqlState)) + return false; + if (__isset.errorCode != rhs.__isset.errorCode) + return false; + else if (__isset.errorCode && !(errorCode == rhs.errorCode)) + return false; + if (__isset.errorMessage != rhs.__isset.errorMessage) + return false; + else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage)) + return false; + return true; + } + bool operator != (const TGetOperationStatusResp &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TGetOperationStatusResp & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(TGetOperationStatusResp &a, TGetOperationStatusResp &b); + +inline std::ostream& operator<<(std::ostream& out, const TGetOperationStatusResp& obj) +{ + obj.printTo(out); + return out; +} + + +class TCancelOperationReq { + public: + + TCancelOperationReq(const TCancelOperationReq&); + TCancelOperationReq& operato
<TRUNCATED>
