| /** |
| * Autogenerated by Thrift Compiler (0.16.0) |
| * |
| * 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/TBase.h> |
| #include <thrift/protocol/TProtocol.h> |
| #include <thrift/transport/TTransport.h> |
| |
| #include <functional> |
| #include <memory> |
| |
| |
| namespace apache { namespace hive { namespace service { namespace rpc { 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, |
| HIVE_CLI_SERVICE_PROTOCOL_V9 = 8, |
| HIVE_CLI_SERVICE_PROTOCOL_V10 = 9, |
| HIVE_CLI_SERVICE_PROTOCOL_V11 = 10 |
| }; |
| }; |
| |
| extern const std::map<int, const char*> _TProtocolVersion_VALUES_TO_NAMES; |
| |
| std::ostream& operator<<(std::ostream& out, const TProtocolVersion::type& val); |
| |
| std::string to_string(const TProtocolVersion::type& val); |
| |
| 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, |
| TIMESTAMPLOCALTZ_TYPE = 22 |
| }; |
| }; |
| |
| extern const std::map<int, const char*> _TTypeId_VALUES_TO_NAMES; |
| |
| std::ostream& operator<<(std::ostream& out, const TTypeId::type& val); |
| |
| std::string to_string(const TTypeId::type& val); |
| |
| 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; |
| |
| std::ostream& operator<<(std::ostream& out, const TStatusCode::type& val); |
| |
| std::string to_string(const TStatusCode::type& val); |
| |
| 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, |
| TIMEDOUT_STATE = 8 |
| }; |
| }; |
| |
| extern const std::map<int, const char*> _TOperationState_VALUES_TO_NAMES; |
| |
| std::ostream& operator<<(std::ostream& out, const TOperationState::type& val); |
| |
| std::string to_string(const TOperationState::type& val); |
| |
| 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, |
| PROCEDURAL_SQL = 9 |
| }; |
| }; |
| |
| extern const std::map<int, const char*> _TOperationType_VALUES_TO_NAMES; |
| |
| std::ostream& operator<<(std::ostream& out, const TOperationType::type& val); |
| |
| std::string to_string(const TOperationType::type& val); |
| |
| 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, |
| CLI_ODBC_KEYWORDS = 10006 |
| }; |
| }; |
| |
| extern const std::map<int, const char*> _TGetInfoType_VALUES_TO_NAMES; |
| |
| std::ostream& operator<<(std::ostream& out, const TGetInfoType::type& val); |
| |
| std::string to_string(const TGetInfoType::type& val); |
| |
| 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; |
| |
| std::ostream& operator<<(std::ostream& out, const TFetchOrientation::type& val); |
| |
| std::string to_string(const TFetchOrientation::type& val); |
| |
| struct TJobExecutionStatus { |
| enum type { |
| IN_PROGRESS = 0, |
| COMPLETE = 1, |
| NOT_AVAILABLE = 2 |
| }; |
| }; |
| |
| extern const std::map<int, const char*> _TJobExecutionStatus_VALUES_TO_NAMES; |
| |
| std::ostream& operator<<(std::ostream& out, const TJobExecutionStatus::type& val); |
| |
| std::string to_string(const TJobExecutionStatus::type& val); |
| |
| 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 TSetClientInfoReq; |
| |
| class TSetClientInfoResp; |
| |
| class TCloseSessionReq; |
| |
| class TCloseSessionResp; |
| |
| class TGetInfoValue; |
| |
| class TGetInfoReq; |
| |
| class TGetInfoResp; |
| |
| class TExecuteStatementReq; |
| |
| class TExecuteStatementResp; |
| |
| class TGetTypeInfoReq; |
| |
| class TGetTypeInfoResp; |
| |
| class TUploadDataReq; |
| |
| class TUploadDataResp; |
| |
| class TDownloadDataReq; |
| |
| class TDownloadDataResp; |
| |
| 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 TGetPrimaryKeysReq; |
| |
| class TGetPrimaryKeysResp; |
| |
| class TGetCrossReferenceReq; |
| |
| class TGetCrossReferenceResp; |
| |
| 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; |
| |
| class TProgressUpdateResp; |
| |
| class TGetQueryIdReq; |
| |
| class TGetQueryIdResp; |
| |
| typedef struct _TTypeQualifierValue__isset { |
| _TTypeQualifierValue__isset() : i32Value(false), stringValue(false) {} |
| bool i32Value :1; |
| bool stringValue :1; |
| } _TTypeQualifierValue__isset; |
| |
| class TTypeQualifierValue : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TTypeQualifierValue(const TTypeQualifierValue&); |
| TTypeQualifierValue& operator=(const TTypeQualifierValue&); |
| TTypeQualifierValue() noexcept |
| : i32Value(0), |
| stringValue() { |
| } |
| |
| virtual ~TTypeQualifierValue() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TTypeQualifierValue &a, TTypeQualifierValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj); |
| |
| |
| class TTypeQualifiers : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TTypeQualifiers(const TTypeQualifiers&); |
| TTypeQualifiers& operator=(const TTypeQualifiers&); |
| TTypeQualifiers() noexcept { |
| } |
| |
| virtual ~TTypeQualifiers() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TTypeQualifiers &a, TTypeQualifiers &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj); |
| |
| typedef struct _TPrimitiveTypeEntry__isset { |
| _TPrimitiveTypeEntry__isset() : typeQualifiers(false) {} |
| bool typeQualifiers :1; |
| } _TPrimitiveTypeEntry__isset; |
| |
| class TPrimitiveTypeEntry : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TPrimitiveTypeEntry(const TPrimitiveTypeEntry&); |
| TPrimitiveTypeEntry& operator=(const TPrimitiveTypeEntry&); |
| TPrimitiveTypeEntry() noexcept |
| : type(static_cast<TTypeId::type>(0)) { |
| } |
| |
| virtual ~TPrimitiveTypeEntry() noexcept; |
| /** |
| * |
| * @see TTypeId |
| */ |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj); |
| |
| |
| class TArrayTypeEntry : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TArrayTypeEntry(const TArrayTypeEntry&) noexcept; |
| TArrayTypeEntry& operator=(const TArrayTypeEntry&) noexcept; |
| TArrayTypeEntry() noexcept |
| : objectTypePtr(0) { |
| } |
| |
| virtual ~TArrayTypeEntry() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TArrayTypeEntry &a, TArrayTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj); |
| |
| |
| class TMapTypeEntry : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TMapTypeEntry(const TMapTypeEntry&) noexcept; |
| TMapTypeEntry& operator=(const TMapTypeEntry&) noexcept; |
| TMapTypeEntry() noexcept |
| : keyTypePtr(0), |
| valueTypePtr(0) { |
| } |
| |
| virtual ~TMapTypeEntry() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TMapTypeEntry &a, TMapTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj); |
| |
| |
| class TStructTypeEntry : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TStructTypeEntry(const TStructTypeEntry&); |
| TStructTypeEntry& operator=(const TStructTypeEntry&); |
| TStructTypeEntry() noexcept { |
| } |
| |
| virtual ~TStructTypeEntry() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TStructTypeEntry &a, TStructTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj); |
| |
| |
| class TUnionTypeEntry : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TUnionTypeEntry(const TUnionTypeEntry&); |
| TUnionTypeEntry& operator=(const TUnionTypeEntry&); |
| TUnionTypeEntry() noexcept { |
| } |
| |
| virtual ~TUnionTypeEntry() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TUnionTypeEntry &a, TUnionTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj); |
| |
| |
| class TUserDefinedTypeEntry : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TUserDefinedTypeEntry(const TUserDefinedTypeEntry&); |
| TUserDefinedTypeEntry& operator=(const TUserDefinedTypeEntry&); |
| TUserDefinedTypeEntry() noexcept |
| : typeClassName() { |
| } |
| |
| virtual ~TUserDefinedTypeEntry() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TTypeEntry(const TTypeEntry&); |
| TTypeEntry& operator=(const TTypeEntry&); |
| TTypeEntry() noexcept { |
| } |
| |
| virtual ~TTypeEntry() noexcept; |
| 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 (__isset.primitiveEntry != rhs.__isset.primitiveEntry) |
| return false; |
| else if (__isset.primitiveEntry && !(primitiveEntry == rhs.primitiveEntry)) |
| return false; |
| if (__isset.arrayEntry != rhs.__isset.arrayEntry) |
| return false; |
| else if (__isset.arrayEntry && !(arrayEntry == rhs.arrayEntry)) |
| return false; |
| if (__isset.mapEntry != rhs.__isset.mapEntry) |
| return false; |
| else if (__isset.mapEntry && !(mapEntry == rhs.mapEntry)) |
| return false; |
| if (__isset.structEntry != rhs.__isset.structEntry) |
| return false; |
| else if (__isset.structEntry && !(structEntry == rhs.structEntry)) |
| return false; |
| if (__isset.unionEntry != rhs.__isset.unionEntry) |
| return false; |
| else if (__isset.unionEntry && !(unionEntry == rhs.unionEntry)) |
| return false; |
| if (__isset.userDefinedTypeEntry != rhs.__isset.userDefinedTypeEntry) |
| return false; |
| else if (__isset.userDefinedTypeEntry && !(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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TTypeEntry &a, TTypeEntry &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj); |
| |
| |
| class TTypeDesc : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TTypeDesc(const TTypeDesc&); |
| TTypeDesc& operator=(const TTypeDesc&); |
| TTypeDesc() noexcept { |
| } |
| |
| virtual ~TTypeDesc() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TTypeDesc &a, TTypeDesc &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj); |
| |
| typedef struct _TColumnDesc__isset { |
| _TColumnDesc__isset() : comment(false) {} |
| bool comment :1; |
| } _TColumnDesc__isset; |
| |
| class TColumnDesc : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TColumnDesc(const TColumnDesc&); |
| TColumnDesc& operator=(const TColumnDesc&); |
| TColumnDesc() noexcept |
| : columnName(), |
| position(0), |
| comment() { |
| } |
| |
| virtual ~TColumnDesc() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TColumnDesc &a, TColumnDesc &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj); |
| |
| |
| class TTableSchema : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TTableSchema(const TTableSchema&); |
| TTableSchema& operator=(const TTableSchema&); |
| TTableSchema() noexcept { |
| } |
| |
| virtual ~TTableSchema() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TTableSchema &a, TTableSchema &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TTableSchema& obj); |
| |
| typedef struct _TBoolValue__isset { |
| _TBoolValue__isset() : value(false) {} |
| bool value :1; |
| } _TBoolValue__isset; |
| |
| class TBoolValue : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TBoolValue(const TBoolValue&) noexcept; |
| TBoolValue& operator=(const TBoolValue&) noexcept; |
| TBoolValue() noexcept |
| : value(0) { |
| } |
| |
| virtual ~TBoolValue() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TBoolValue &a, TBoolValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TBoolValue& obj); |
| |
| typedef struct _TByteValue__isset { |
| _TByteValue__isset() : value(false) {} |
| bool value :1; |
| } _TByteValue__isset; |
| |
| class TByteValue : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TByteValue(const TByteValue&) noexcept; |
| TByteValue& operator=(const TByteValue&) noexcept; |
| TByteValue() noexcept |
| : value(0) { |
| } |
| |
| virtual ~TByteValue() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TByteValue &a, TByteValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TByteValue& obj); |
| |
| typedef struct _TI16Value__isset { |
| _TI16Value__isset() : value(false) {} |
| bool value :1; |
| } _TI16Value__isset; |
| |
| class TI16Value : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TI16Value(const TI16Value&) noexcept; |
| TI16Value& operator=(const TI16Value&) noexcept; |
| TI16Value() noexcept |
| : value(0) { |
| } |
| |
| virtual ~TI16Value() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TI16Value &a, TI16Value &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TI16Value& obj); |
| |
| typedef struct _TI32Value__isset { |
| _TI32Value__isset() : value(false) {} |
| bool value :1; |
| } _TI32Value__isset; |
| |
| class TI32Value : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TI32Value(const TI32Value&) noexcept; |
| TI32Value& operator=(const TI32Value&) noexcept; |
| TI32Value() noexcept |
| : value(0) { |
| } |
| |
| virtual ~TI32Value() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TI32Value &a, TI32Value &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TI32Value& obj); |
| |
| typedef struct _TI64Value__isset { |
| _TI64Value__isset() : value(false) {} |
| bool value :1; |
| } _TI64Value__isset; |
| |
| class TI64Value : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TI64Value(const TI64Value&) noexcept; |
| TI64Value& operator=(const TI64Value&) noexcept; |
| TI64Value() noexcept |
| : value(0) { |
| } |
| |
| virtual ~TI64Value() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TI64Value &a, TI64Value &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TI64Value& obj); |
| |
| typedef struct _TDoubleValue__isset { |
| _TDoubleValue__isset() : value(false) {} |
| bool value :1; |
| } _TDoubleValue__isset; |
| |
| class TDoubleValue : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TDoubleValue(const TDoubleValue&) noexcept; |
| TDoubleValue& operator=(const TDoubleValue&) noexcept; |
| TDoubleValue() noexcept |
| : value(0) { |
| } |
| |
| virtual ~TDoubleValue() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TDoubleValue &a, TDoubleValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj); |
| |
| typedef struct _TStringValue__isset { |
| _TStringValue__isset() : value(false) {} |
| bool value :1; |
| } _TStringValue__isset; |
| |
| class TStringValue : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TStringValue(const TStringValue&); |
| TStringValue& operator=(const TStringValue&); |
| TStringValue() noexcept |
| : value() { |
| } |
| |
| virtual ~TStringValue() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TStringValue &a, TStringValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TStringValue& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TColumnValue(const TColumnValue&); |
| TColumnValue& operator=(const TColumnValue&); |
| TColumnValue() noexcept { |
| } |
| |
| virtual ~TColumnValue() noexcept; |
| 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 (__isset.boolVal != rhs.__isset.boolVal) |
| return false; |
| else if (__isset.boolVal && !(boolVal == rhs.boolVal)) |
| return false; |
| if (__isset.byteVal != rhs.__isset.byteVal) |
| return false; |
| else if (__isset.byteVal && !(byteVal == rhs.byteVal)) |
| return false; |
| if (__isset.i16Val != rhs.__isset.i16Val) |
| return false; |
| else if (__isset.i16Val && !(i16Val == rhs.i16Val)) |
| return false; |
| if (__isset.i32Val != rhs.__isset.i32Val) |
| return false; |
| else if (__isset.i32Val && !(i32Val == rhs.i32Val)) |
| return false; |
| if (__isset.i64Val != rhs.__isset.i64Val) |
| return false; |
| else if (__isset.i64Val && !(i64Val == rhs.i64Val)) |
| return false; |
| if (__isset.doubleVal != rhs.__isset.doubleVal) |
| return false; |
| else if (__isset.doubleVal && !(doubleVal == rhs.doubleVal)) |
| return false; |
| if (__isset.stringVal != rhs.__isset.stringVal) |
| return false; |
| else if (__isset.stringVal && !(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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TColumnValue &a, TColumnValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TColumnValue& obj); |
| |
| |
| class TRow : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TRow(const TRow&); |
| TRow& operator=(const TRow&); |
| TRow() noexcept { |
| } |
| |
| virtual ~TRow() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TRow &a, TRow &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TRow& obj); |
| |
| |
| class TBoolColumn : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TBoolColumn(const TBoolColumn&); |
| TBoolColumn& operator=(const TBoolColumn&); |
| TBoolColumn() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TBoolColumn() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TBoolColumn &a, TBoolColumn &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj); |
| |
| |
| class TByteColumn : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TByteColumn(const TByteColumn&); |
| TByteColumn& operator=(const TByteColumn&); |
| TByteColumn() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TByteColumn() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TByteColumn &a, TByteColumn &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TByteColumn& obj); |
| |
| |
| class TI16Column : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TI16Column(const TI16Column&); |
| TI16Column& operator=(const TI16Column&); |
| TI16Column() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TI16Column() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TI16Column &a, TI16Column &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TI16Column& obj); |
| |
| |
| class TI32Column : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TI32Column(const TI32Column&); |
| TI32Column& operator=(const TI32Column&); |
| TI32Column() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TI32Column() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TI32Column &a, TI32Column &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TI32Column& obj); |
| |
| |
| class TI64Column : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TI64Column(const TI64Column&); |
| TI64Column& operator=(const TI64Column&); |
| TI64Column() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TI64Column() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TI64Column &a, TI64Column &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TI64Column& obj); |
| |
| |
| class TDoubleColumn : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TDoubleColumn(const TDoubleColumn&); |
| TDoubleColumn& operator=(const TDoubleColumn&); |
| TDoubleColumn() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TDoubleColumn() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TDoubleColumn &a, TDoubleColumn &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj); |
| |
| |
| class TStringColumn : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TStringColumn(const TStringColumn&); |
| TStringColumn& operator=(const TStringColumn&); |
| TStringColumn() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TStringColumn() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TStringColumn &a, TStringColumn &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TStringColumn& obj); |
| |
| |
| class TBinaryColumn : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TBinaryColumn(const TBinaryColumn&); |
| TBinaryColumn& operator=(const TBinaryColumn&); |
| TBinaryColumn() noexcept |
| : nulls() { |
| } |
| |
| virtual ~TBinaryColumn() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TBinaryColumn &a, TBinaryColumn &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TColumn(const TColumn&); |
| TColumn& operator=(const TColumn&); |
| TColumn() noexcept { |
| } |
| |
| virtual ~TColumn() noexcept; |
| 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 (__isset.boolVal != rhs.__isset.boolVal) |
| return false; |
| else if (__isset.boolVal && !(boolVal == rhs.boolVal)) |
| return false; |
| if (__isset.byteVal != rhs.__isset.byteVal) |
| return false; |
| else if (__isset.byteVal && !(byteVal == rhs.byteVal)) |
| return false; |
| if (__isset.i16Val != rhs.__isset.i16Val) |
| return false; |
| else if (__isset.i16Val && !(i16Val == rhs.i16Val)) |
| return false; |
| if (__isset.i32Val != rhs.__isset.i32Val) |
| return false; |
| else if (__isset.i32Val && !(i32Val == rhs.i32Val)) |
| return false; |
| if (__isset.i64Val != rhs.__isset.i64Val) |
| return false; |
| else if (__isset.i64Val && !(i64Val == rhs.i64Val)) |
| return false; |
| if (__isset.doubleVal != rhs.__isset.doubleVal) |
| return false; |
| else if (__isset.doubleVal && !(doubleVal == rhs.doubleVal)) |
| return false; |
| if (__isset.stringVal != rhs.__isset.stringVal) |
| return false; |
| else if (__isset.stringVal && !(stringVal == rhs.stringVal)) |
| return false; |
| if (__isset.binaryVal != rhs.__isset.binaryVal) |
| return false; |
| else if (__isset.binaryVal && !(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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TColumn &a, TColumn &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TColumn& obj); |
| |
| typedef struct _TRowSet__isset { |
| _TRowSet__isset() : columns(false), binaryColumns(false), columnCount(false) {} |
| bool columns :1; |
| bool binaryColumns :1; |
| bool columnCount :1; |
| } _TRowSet__isset; |
| |
| class TRowSet : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TRowSet(const TRowSet&); |
| TRowSet& operator=(const TRowSet&); |
| TRowSet() noexcept |
| : startRowOffset(0), |
| binaryColumns(), |
| columnCount(0) { |
| } |
| |
| virtual ~TRowSet() noexcept; |
| int64_t startRowOffset; |
| std::vector<TRow> rows; |
| std::vector<TColumn> columns; |
| std::string binaryColumns; |
| int32_t columnCount; |
| |
| _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); |
| |
| void __set_binaryColumns(const std::string& val); |
| |
| void __set_columnCount(const int32_t 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; |
| if (__isset.binaryColumns != rhs.__isset.binaryColumns) |
| return false; |
| else if (__isset.binaryColumns && !(binaryColumns == rhs.binaryColumns)) |
| return false; |
| if (__isset.columnCount != rhs.__isset.columnCount) |
| return false; |
| else if (__isset.columnCount && !(columnCount == rhs.columnCount)) |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TRowSet &a, TRowSet &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TRowSet& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TStatus(const TStatus&); |
| TStatus& operator=(const TStatus&); |
| TStatus() noexcept |
| : statusCode(static_cast<TStatusCode::type>(0)), |
| sqlState(), |
| errorCode(0), |
| errorMessage() { |
| } |
| |
| virtual ~TStatus() noexcept; |
| /** |
| * |
| * @see TStatusCode |
| */ |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TStatus &a, TStatus &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TStatus& obj); |
| |
| |
| class THandleIdentifier : public virtual ::apache::thrift::TBase { |
| public: |
| |
| THandleIdentifier(const THandleIdentifier&); |
| THandleIdentifier& operator=(const THandleIdentifier&); |
| THandleIdentifier() noexcept |
| : guid(), |
| secret() { |
| } |
| |
| virtual ~THandleIdentifier() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(THandleIdentifier &a, THandleIdentifier &b); |
| |
| std::ostream& operator<<(std::ostream& out, const THandleIdentifier& obj); |
| |
| |
| class TSessionHandle : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TSessionHandle(const TSessionHandle&); |
| TSessionHandle& operator=(const TSessionHandle&); |
| TSessionHandle() noexcept { |
| } |
| |
| virtual ~TSessionHandle() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TSessionHandle &a, TSessionHandle &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TSessionHandle& obj); |
| |
| typedef struct _TOperationHandle__isset { |
| _TOperationHandle__isset() : modifiedRowCount(false) {} |
| bool modifiedRowCount :1; |
| } _TOperationHandle__isset; |
| |
| class TOperationHandle : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TOperationHandle(const TOperationHandle&); |
| TOperationHandle& operator=(const TOperationHandle&); |
| TOperationHandle() noexcept |
| : operationType(static_cast<TOperationType::type>(0)), |
| hasResultSet(0), |
| modifiedRowCount(0) { |
| } |
| |
| virtual ~TOperationHandle() noexcept; |
| THandleIdentifier operationId; |
| /** |
| * |
| * @see TOperationType |
| */ |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TOperationHandle &a, TOperationHandle &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TOperationHandle& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TOpenSessionReq(const TOpenSessionReq&); |
| TOpenSessionReq& operator=(const TOpenSessionReq&); |
| TOpenSessionReq() noexcept |
| : client_protocol((TProtocolVersion::type)9), |
| username(), |
| password() { |
| client_protocol = (TProtocolVersion::type)9; |
| |
| } |
| |
| virtual ~TOpenSessionReq() noexcept; |
| /** |
| * |
| * @see TProtocolVersion |
| */ |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TOpenSessionReq &a, TOpenSessionReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TOpenSessionReq& obj); |
| |
| typedef struct _TOpenSessionResp__isset { |
| _TOpenSessionResp__isset() : sessionHandle(false), configuration(false) {} |
| bool sessionHandle :1; |
| bool configuration :1; |
| } _TOpenSessionResp__isset; |
| |
| class TOpenSessionResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TOpenSessionResp(const TOpenSessionResp&); |
| TOpenSessionResp& operator=(const TOpenSessionResp&); |
| TOpenSessionResp() noexcept |
| : serverProtocolVersion((TProtocolVersion::type)9) { |
| serverProtocolVersion = (TProtocolVersion::type)9; |
| |
| } |
| |
| virtual ~TOpenSessionResp() noexcept; |
| TStatus status; |
| /** |
| * |
| * @see TProtocolVersion |
| */ |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TOpenSessionResp &a, TOpenSessionResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TOpenSessionResp& obj); |
| |
| typedef struct _TSetClientInfoReq__isset { |
| _TSetClientInfoReq__isset() : configuration(false) {} |
| bool configuration :1; |
| } _TSetClientInfoReq__isset; |
| |
| class TSetClientInfoReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TSetClientInfoReq(const TSetClientInfoReq&); |
| TSetClientInfoReq& operator=(const TSetClientInfoReq&); |
| TSetClientInfoReq() noexcept { |
| } |
| |
| virtual ~TSetClientInfoReq() noexcept; |
| TSessionHandle sessionHandle; |
| std::map<std::string, std::string> configuration; |
| |
| _TSetClientInfoReq__isset __isset; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_configuration(const std::map<std::string, std::string> & val); |
| |
| bool operator == (const TSetClientInfoReq & rhs) const |
| { |
| if (!(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 TSetClientInfoReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TSetClientInfoReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TSetClientInfoReq &a, TSetClientInfoReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TSetClientInfoReq& obj); |
| |
| |
| class TSetClientInfoResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TSetClientInfoResp(const TSetClientInfoResp&); |
| TSetClientInfoResp& operator=(const TSetClientInfoResp&); |
| TSetClientInfoResp() noexcept { |
| } |
| |
| virtual ~TSetClientInfoResp() noexcept; |
| TStatus status; |
| |
| void __set_status(const TStatus& val); |
| |
| bool operator == (const TSetClientInfoResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| return true; |
| } |
| bool operator != (const TSetClientInfoResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TSetClientInfoResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TSetClientInfoResp &a, TSetClientInfoResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TSetClientInfoResp& obj); |
| |
| |
| class TCloseSessionReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCloseSessionReq(const TCloseSessionReq&); |
| TCloseSessionReq& operator=(const TCloseSessionReq&); |
| TCloseSessionReq() noexcept { |
| } |
| |
| virtual ~TCloseSessionReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCloseSessionReq &a, TCloseSessionReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCloseSessionReq& obj); |
| |
| |
| class TCloseSessionResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCloseSessionResp(const TCloseSessionResp&); |
| TCloseSessionResp& operator=(const TCloseSessionResp&); |
| TCloseSessionResp() noexcept { |
| } |
| |
| virtual ~TCloseSessionResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCloseSessionResp &a, TCloseSessionResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCloseSessionResp& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetInfoValue(const TGetInfoValue&); |
| TGetInfoValue& operator=(const TGetInfoValue&); |
| TGetInfoValue() noexcept |
| : stringValue(), |
| smallIntValue(0), |
| integerBitmask(0), |
| integerFlag(0), |
| binaryValue(0), |
| lenValue(0) { |
| } |
| |
| virtual ~TGetInfoValue() noexcept; |
| 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 (__isset.stringValue != rhs.__isset.stringValue) |
| return false; |
| else if (__isset.stringValue && !(stringValue == rhs.stringValue)) |
| return false; |
| if (__isset.smallIntValue != rhs.__isset.smallIntValue) |
| return false; |
| else if (__isset.smallIntValue && !(smallIntValue == rhs.smallIntValue)) |
| return false; |
| if (__isset.integerBitmask != rhs.__isset.integerBitmask) |
| return false; |
| else if (__isset.integerBitmask && !(integerBitmask == rhs.integerBitmask)) |
| return false; |
| if (__isset.integerFlag != rhs.__isset.integerFlag) |
| return false; |
| else if (__isset.integerFlag && !(integerFlag == rhs.integerFlag)) |
| return false; |
| if (__isset.binaryValue != rhs.__isset.binaryValue) |
| return false; |
| else if (__isset.binaryValue && !(binaryValue == rhs.binaryValue)) |
| return false; |
| if (__isset.lenValue != rhs.__isset.lenValue) |
| return false; |
| else if (__isset.lenValue && !(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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetInfoValue &a, TGetInfoValue &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetInfoValue& obj); |
| |
| |
| class TGetInfoReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetInfoReq(const TGetInfoReq&); |
| TGetInfoReq& operator=(const TGetInfoReq&); |
| TGetInfoReq() noexcept |
| : infoType(static_cast<TGetInfoType::type>(0)) { |
| } |
| |
| virtual ~TGetInfoReq() noexcept; |
| TSessionHandle sessionHandle; |
| /** |
| * |
| * @see TGetInfoType |
| */ |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetInfoReq &a, TGetInfoReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetInfoReq& obj); |
| |
| |
| class TGetInfoResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetInfoResp(const TGetInfoResp&); |
| TGetInfoResp& operator=(const TGetInfoResp&); |
| TGetInfoResp() noexcept { |
| } |
| |
| virtual ~TGetInfoResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetInfoResp &a, TGetInfoResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetInfoResp& obj); |
| |
| typedef struct _TExecuteStatementReq__isset { |
| _TExecuteStatementReq__isset() : confOverlay(false), runAsync(true), queryTimeout(true) {} |
| bool confOverlay :1; |
| bool runAsync :1; |
| bool queryTimeout :1; |
| } _TExecuteStatementReq__isset; |
| |
| class TExecuteStatementReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TExecuteStatementReq(const TExecuteStatementReq&); |
| TExecuteStatementReq& operator=(const TExecuteStatementReq&); |
| TExecuteStatementReq() noexcept |
| : statement(), |
| runAsync(false), |
| queryTimeout(0LL) { |
| } |
| |
| virtual ~TExecuteStatementReq() noexcept; |
| TSessionHandle sessionHandle; |
| std::string statement; |
| std::map<std::string, std::string> confOverlay; |
| bool runAsync; |
| int64_t queryTimeout; |
| |
| _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); |
| |
| void __set_queryTimeout(const int64_t 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; |
| if (__isset.queryTimeout != rhs.__isset.queryTimeout) |
| return false; |
| else if (__isset.queryTimeout && !(queryTimeout == rhs.queryTimeout)) |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TExecuteStatementReq &a, TExecuteStatementReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TExecuteStatementReq& obj); |
| |
| typedef struct _TExecuteStatementResp__isset { |
| _TExecuteStatementResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TExecuteStatementResp__isset; |
| |
| class TExecuteStatementResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TExecuteStatementResp(const TExecuteStatementResp&); |
| TExecuteStatementResp& operator=(const TExecuteStatementResp&); |
| TExecuteStatementResp() noexcept { |
| } |
| |
| virtual ~TExecuteStatementResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TExecuteStatementResp &a, TExecuteStatementResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TExecuteStatementResp& obj); |
| |
| |
| class TGetTypeInfoReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetTypeInfoReq(const TGetTypeInfoReq&); |
| TGetTypeInfoReq& operator=(const TGetTypeInfoReq&); |
| TGetTypeInfoReq() noexcept { |
| } |
| |
| virtual ~TGetTypeInfoReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetTypeInfoReq &a, TGetTypeInfoReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetTypeInfoReq& obj); |
| |
| typedef struct _TGetTypeInfoResp__isset { |
| _TGetTypeInfoResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetTypeInfoResp__isset; |
| |
| class TGetTypeInfoResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetTypeInfoResp(const TGetTypeInfoResp&); |
| TGetTypeInfoResp& operator=(const TGetTypeInfoResp&); |
| TGetTypeInfoResp() noexcept { |
| } |
| |
| virtual ~TGetTypeInfoResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetTypeInfoResp &a, TGetTypeInfoResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetTypeInfoResp& obj); |
| |
| typedef struct _TUploadDataReq__isset { |
| _TUploadDataReq__isset() : tableName(false), path(false) {} |
| bool tableName :1; |
| bool path :1; |
| } _TUploadDataReq__isset; |
| |
| class TUploadDataReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TUploadDataReq(const TUploadDataReq&); |
| TUploadDataReq& operator=(const TUploadDataReq&); |
| TUploadDataReq() noexcept |
| : tableName(), |
| path(), |
| values() { |
| } |
| |
| virtual ~TUploadDataReq() noexcept; |
| TSessionHandle sessionHandle; |
| std::string tableName; |
| std::string path; |
| std::string values; |
| |
| _TUploadDataReq__isset __isset; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_tableName(const std::string& val); |
| |
| void __set_path(const std::string& val); |
| |
| void __set_values(const std::string& val); |
| |
| bool operator == (const TUploadDataReq & rhs) const |
| { |
| if (!(sessionHandle == rhs.sessionHandle)) |
| return false; |
| if (__isset.tableName != rhs.__isset.tableName) |
| return false; |
| else if (__isset.tableName && !(tableName == rhs.tableName)) |
| return false; |
| if (__isset.path != rhs.__isset.path) |
| return false; |
| else if (__isset.path && !(path == rhs.path)) |
| return false; |
| if (!(values == rhs.values)) |
| return false; |
| return true; |
| } |
| bool operator != (const TUploadDataReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TUploadDataReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TUploadDataReq &a, TUploadDataReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TUploadDataReq& obj); |
| |
| |
| class TUploadDataResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TUploadDataResp(const TUploadDataResp&); |
| TUploadDataResp& operator=(const TUploadDataResp&); |
| TUploadDataResp() noexcept { |
| } |
| |
| virtual ~TUploadDataResp() noexcept; |
| TStatus status; |
| TOperationHandle operationHandle; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TUploadDataResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| return true; |
| } |
| bool operator != (const TUploadDataResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TUploadDataResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TUploadDataResp &a, TUploadDataResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TUploadDataResp& obj); |
| |
| typedef struct _TDownloadDataReq__isset { |
| _TDownloadDataReq__isset() : tableName(false), query(false), format(false), downloadOptions(false) {} |
| bool tableName :1; |
| bool query :1; |
| bool format :1; |
| bool downloadOptions :1; |
| } _TDownloadDataReq__isset; |
| |
| class TDownloadDataReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TDownloadDataReq(const TDownloadDataReq&); |
| TDownloadDataReq& operator=(const TDownloadDataReq&); |
| TDownloadDataReq() noexcept |
| : tableName(), |
| query(), |
| format() { |
| } |
| |
| virtual ~TDownloadDataReq() noexcept; |
| TSessionHandle sessionHandle; |
| TPatternOrIdentifier tableName; |
| std::string query; |
| std::string format; |
| std::map<std::string, std::string> downloadOptions; |
| |
| _TDownloadDataReq__isset __isset; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_tableName(const TPatternOrIdentifier& val); |
| |
| void __set_query(const std::string& val); |
| |
| void __set_format(const std::string& val); |
| |
| void __set_downloadOptions(const std::map<std::string, std::string> & val); |
| |
| bool operator == (const TDownloadDataReq & rhs) const |
| { |
| if (!(sessionHandle == rhs.sessionHandle)) |
| return false; |
| if (__isset.tableName != rhs.__isset.tableName) |
| return false; |
| else if (__isset.tableName && !(tableName == rhs.tableName)) |
| return false; |
| if (__isset.query != rhs.__isset.query) |
| return false; |
| else if (__isset.query && !(query == rhs.query)) |
| return false; |
| if (__isset.format != rhs.__isset.format) |
| return false; |
| else if (__isset.format && !(format == rhs.format)) |
| return false; |
| if (__isset.downloadOptions != rhs.__isset.downloadOptions) |
| return false; |
| else if (__isset.downloadOptions && !(downloadOptions == rhs.downloadOptions)) |
| return false; |
| return true; |
| } |
| bool operator != (const TDownloadDataReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TDownloadDataReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TDownloadDataReq &a, TDownloadDataReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TDownloadDataReq& obj); |
| |
| |
| class TDownloadDataResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TDownloadDataResp(const TDownloadDataResp&); |
| TDownloadDataResp& operator=(const TDownloadDataResp&); |
| TDownloadDataResp() noexcept { |
| } |
| |
| virtual ~TDownloadDataResp() noexcept; |
| TStatus status; |
| TOperationHandle operationHandle; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TDownloadDataResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| return true; |
| } |
| bool operator != (const TDownloadDataResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TDownloadDataResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TDownloadDataResp &a, TDownloadDataResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TDownloadDataResp& obj); |
| |
| |
| class TGetCatalogsReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetCatalogsReq(const TGetCatalogsReq&); |
| TGetCatalogsReq& operator=(const TGetCatalogsReq&); |
| TGetCatalogsReq() noexcept { |
| } |
| |
| virtual ~TGetCatalogsReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetCatalogsReq &a, TGetCatalogsReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetCatalogsReq& obj); |
| |
| typedef struct _TGetCatalogsResp__isset { |
| _TGetCatalogsResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetCatalogsResp__isset; |
| |
| class TGetCatalogsResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetCatalogsResp(const TGetCatalogsResp&); |
| TGetCatalogsResp& operator=(const TGetCatalogsResp&); |
| TGetCatalogsResp() noexcept { |
| } |
| |
| virtual ~TGetCatalogsResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetCatalogsResp &a, TGetCatalogsResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetCatalogsResp& obj); |
| |
| typedef struct _TGetSchemasReq__isset { |
| _TGetSchemasReq__isset() : catalogName(false), schemaName(false) {} |
| bool catalogName :1; |
| bool schemaName :1; |
| } _TGetSchemasReq__isset; |
| |
| class TGetSchemasReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetSchemasReq(const TGetSchemasReq&); |
| TGetSchemasReq& operator=(const TGetSchemasReq&); |
| TGetSchemasReq() noexcept |
| : catalogName(), |
| schemaName() { |
| } |
| |
| virtual ~TGetSchemasReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetSchemasReq &a, TGetSchemasReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetSchemasReq& obj); |
| |
| typedef struct _TGetSchemasResp__isset { |
| _TGetSchemasResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetSchemasResp__isset; |
| |
| class TGetSchemasResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetSchemasResp(const TGetSchemasResp&); |
| TGetSchemasResp& operator=(const TGetSchemasResp&); |
| TGetSchemasResp() noexcept { |
| } |
| |
| virtual ~TGetSchemasResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetSchemasResp &a, TGetSchemasResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetSchemasResp& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetTablesReq(const TGetTablesReq&); |
| TGetTablesReq& operator=(const TGetTablesReq&); |
| TGetTablesReq() noexcept |
| : catalogName(), |
| schemaName(), |
| tableName() { |
| } |
| |
| virtual ~TGetTablesReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetTablesReq &a, TGetTablesReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetTablesReq& obj); |
| |
| typedef struct _TGetTablesResp__isset { |
| _TGetTablesResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetTablesResp__isset; |
| |
| class TGetTablesResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetTablesResp(const TGetTablesResp&); |
| TGetTablesResp& operator=(const TGetTablesResp&); |
| TGetTablesResp() noexcept { |
| } |
| |
| virtual ~TGetTablesResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetTablesResp &a, TGetTablesResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetTablesResp& obj); |
| |
| |
| class TGetTableTypesReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetTableTypesReq(const TGetTableTypesReq&); |
| TGetTableTypesReq& operator=(const TGetTableTypesReq&); |
| TGetTableTypesReq() noexcept { |
| } |
| |
| virtual ~TGetTableTypesReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetTableTypesReq &a, TGetTableTypesReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetTableTypesReq& obj); |
| |
| typedef struct _TGetTableTypesResp__isset { |
| _TGetTableTypesResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetTableTypesResp__isset; |
| |
| class TGetTableTypesResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetTableTypesResp(const TGetTableTypesResp&); |
| TGetTableTypesResp& operator=(const TGetTableTypesResp&); |
| TGetTableTypesResp() noexcept { |
| } |
| |
| virtual ~TGetTableTypesResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetTableTypesResp &a, TGetTableTypesResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetTableTypesResp& obj); |
| |
| 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 virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetColumnsReq(const TGetColumnsReq&); |
| TGetColumnsReq& operator=(const TGetColumnsReq&); |
| TGetColumnsReq() noexcept |
| : catalogName(), |
| schemaName(), |
| tableName(), |
| columnName() { |
| } |
| |
| virtual ~TGetColumnsReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetColumnsReq &a, TGetColumnsReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetColumnsReq& obj); |
| |
| typedef struct _TGetColumnsResp__isset { |
| _TGetColumnsResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetColumnsResp__isset; |
| |
| class TGetColumnsResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetColumnsResp(const TGetColumnsResp&); |
| TGetColumnsResp& operator=(const TGetColumnsResp&); |
| TGetColumnsResp() noexcept { |
| } |
| |
| virtual ~TGetColumnsResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetColumnsResp &a, TGetColumnsResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetColumnsResp& obj); |
| |
| typedef struct _TGetFunctionsReq__isset { |
| _TGetFunctionsReq__isset() : catalogName(false), schemaName(false) {} |
| bool catalogName :1; |
| bool schemaName :1; |
| } _TGetFunctionsReq__isset; |
| |
| class TGetFunctionsReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetFunctionsReq(const TGetFunctionsReq&); |
| TGetFunctionsReq& operator=(const TGetFunctionsReq&); |
| TGetFunctionsReq() noexcept |
| : catalogName(), |
| schemaName(), |
| functionName() { |
| } |
| |
| virtual ~TGetFunctionsReq() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetFunctionsReq &a, TGetFunctionsReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetFunctionsReq& obj); |
| |
| typedef struct _TGetFunctionsResp__isset { |
| _TGetFunctionsResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetFunctionsResp__isset; |
| |
| class TGetFunctionsResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetFunctionsResp(const TGetFunctionsResp&); |
| TGetFunctionsResp& operator=(const TGetFunctionsResp&); |
| TGetFunctionsResp() noexcept { |
| } |
| |
| virtual ~TGetFunctionsResp() noexcept; |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetFunctionsResp &a, TGetFunctionsResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetFunctionsResp& obj); |
| |
| typedef struct _TGetPrimaryKeysReq__isset { |
| _TGetPrimaryKeysReq__isset() : catalogName(false), schemaName(false), tableName(false) {} |
| bool catalogName :1; |
| bool schemaName :1; |
| bool tableName :1; |
| } _TGetPrimaryKeysReq__isset; |
| |
| class TGetPrimaryKeysReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetPrimaryKeysReq(const TGetPrimaryKeysReq&); |
| TGetPrimaryKeysReq& operator=(const TGetPrimaryKeysReq&); |
| TGetPrimaryKeysReq() noexcept |
| : catalogName(), |
| schemaName(), |
| tableName() { |
| } |
| |
| virtual ~TGetPrimaryKeysReq() noexcept; |
| TSessionHandle sessionHandle; |
| TIdentifier catalogName; |
| TIdentifier schemaName; |
| TIdentifier tableName; |
| |
| _TGetPrimaryKeysReq__isset __isset; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_catalogName(const TIdentifier& val); |
| |
| void __set_schemaName(const TIdentifier& val); |
| |
| void __set_tableName(const TIdentifier& val); |
| |
| bool operator == (const TGetPrimaryKeysReq & 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; |
| return true; |
| } |
| bool operator != (const TGetPrimaryKeysReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetPrimaryKeysReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetPrimaryKeysReq &a, TGetPrimaryKeysReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetPrimaryKeysReq& obj); |
| |
| typedef struct _TGetPrimaryKeysResp__isset { |
| _TGetPrimaryKeysResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetPrimaryKeysResp__isset; |
| |
| class TGetPrimaryKeysResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetPrimaryKeysResp(const TGetPrimaryKeysResp&); |
| TGetPrimaryKeysResp& operator=(const TGetPrimaryKeysResp&); |
| TGetPrimaryKeysResp() noexcept { |
| } |
| |
| virtual ~TGetPrimaryKeysResp() noexcept; |
| TStatus status; |
| TOperationHandle operationHandle; |
| |
| _TGetPrimaryKeysResp__isset __isset; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TGetPrimaryKeysResp & 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 TGetPrimaryKeysResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetPrimaryKeysResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetPrimaryKeysResp &a, TGetPrimaryKeysResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetPrimaryKeysResp& obj); |
| |
| typedef struct _TGetCrossReferenceReq__isset { |
| _TGetCrossReferenceReq__isset() : parentCatalogName(false), parentSchemaName(false), parentTableName(false), foreignCatalogName(false), foreignSchemaName(false), foreignTableName(false) {} |
| bool parentCatalogName :1; |
| bool parentSchemaName :1; |
| bool parentTableName :1; |
| bool foreignCatalogName :1; |
| bool foreignSchemaName :1; |
| bool foreignTableName :1; |
| } _TGetCrossReferenceReq__isset; |
| |
| class TGetCrossReferenceReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetCrossReferenceReq(const TGetCrossReferenceReq&); |
| TGetCrossReferenceReq& operator=(const TGetCrossReferenceReq&); |
| TGetCrossReferenceReq() noexcept |
| : parentCatalogName(), |
| parentSchemaName(), |
| parentTableName(), |
| foreignCatalogName(), |
| foreignSchemaName(), |
| foreignTableName() { |
| } |
| |
| virtual ~TGetCrossReferenceReq() noexcept; |
| TSessionHandle sessionHandle; |
| TIdentifier parentCatalogName; |
| TIdentifier parentSchemaName; |
| TIdentifier parentTableName; |
| TIdentifier foreignCatalogName; |
| TIdentifier foreignSchemaName; |
| TIdentifier foreignTableName; |
| |
| _TGetCrossReferenceReq__isset __isset; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_parentCatalogName(const TIdentifier& val); |
| |
| void __set_parentSchemaName(const TIdentifier& val); |
| |
| void __set_parentTableName(const TIdentifier& val); |
| |
| void __set_foreignCatalogName(const TIdentifier& val); |
| |
| void __set_foreignSchemaName(const TIdentifier& val); |
| |
| void __set_foreignTableName(const TIdentifier& val); |
| |
| bool operator == (const TGetCrossReferenceReq & rhs) const |
| { |
| if (!(sessionHandle == rhs.sessionHandle)) |
| return false; |
| if (__isset.parentCatalogName != rhs.__isset.parentCatalogName) |
| return false; |
| else if (__isset.parentCatalogName && !(parentCatalogName == rhs.parentCatalogName)) |
| return false; |
| if (__isset.parentSchemaName != rhs.__isset.parentSchemaName) |
| return false; |
| else if (__isset.parentSchemaName && !(parentSchemaName == rhs.parentSchemaName)) |
| return false; |
| if (__isset.parentTableName != rhs.__isset.parentTableName) |
| return false; |
| else if (__isset.parentTableName && !(parentTableName == rhs.parentTableName)) |
| return false; |
| if (__isset.foreignCatalogName != rhs.__isset.foreignCatalogName) |
| return false; |
| else if (__isset.foreignCatalogName && !(foreignCatalogName == rhs.foreignCatalogName)) |
| return false; |
| if (__isset.foreignSchemaName != rhs.__isset.foreignSchemaName) |
| return false; |
| else if (__isset.foreignSchemaName && !(foreignSchemaName == rhs.foreignSchemaName)) |
| return false; |
| if (__isset.foreignTableName != rhs.__isset.foreignTableName) |
| return false; |
| else if (__isset.foreignTableName && !(foreignTableName == rhs.foreignTableName)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetCrossReferenceReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetCrossReferenceReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetCrossReferenceReq &a, TGetCrossReferenceReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetCrossReferenceReq& obj); |
| |
| typedef struct _TGetCrossReferenceResp__isset { |
| _TGetCrossReferenceResp__isset() : operationHandle(false) {} |
| bool operationHandle :1; |
| } _TGetCrossReferenceResp__isset; |
| |
| class TGetCrossReferenceResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetCrossReferenceResp(const TGetCrossReferenceResp&); |
| TGetCrossReferenceResp& operator=(const TGetCrossReferenceResp&); |
| TGetCrossReferenceResp() noexcept { |
| } |
| |
| virtual ~TGetCrossReferenceResp() noexcept; |
| TStatus status; |
| TOperationHandle operationHandle; |
| |
| _TGetCrossReferenceResp__isset __isset; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TGetCrossReferenceResp & 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 TGetCrossReferenceResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetCrossReferenceResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetCrossReferenceResp &a, TGetCrossReferenceResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetCrossReferenceResp& obj); |
| |
| typedef struct _TGetOperationStatusReq__isset { |
| _TGetOperationStatusReq__isset() : getProgressUpdate(false) {} |
| bool getProgressUpdate :1; |
| } _TGetOperationStatusReq__isset; |
| |
| class TGetOperationStatusReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetOperationStatusReq(const TGetOperationStatusReq&); |
| TGetOperationStatusReq& operator=(const TGetOperationStatusReq&); |
| TGetOperationStatusReq() noexcept |
| : getProgressUpdate(0) { |
| } |
| |
| virtual ~TGetOperationStatusReq() noexcept; |
| TOperationHandle operationHandle; |
| bool getProgressUpdate; |
| |
| _TGetOperationStatusReq__isset __isset; |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| void __set_getProgressUpdate(const bool val); |
| |
| bool operator == (const TGetOperationStatusReq & rhs) const |
| { |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| if (__isset.getProgressUpdate != rhs.__isset.getProgressUpdate) |
| return false; |
| else if (__isset.getProgressUpdate && !(getProgressUpdate == rhs.getProgressUpdate)) |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetOperationStatusReq &a, TGetOperationStatusReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetOperationStatusReq& obj); |
| |
| typedef struct _TGetOperationStatusResp__isset { |
| _TGetOperationStatusResp__isset() : operationState(false), sqlState(false), errorCode(false), errorMessage(false), taskStatus(false), operationStarted(false), operationCompleted(false), hasResultSet(false), progressUpdateResponse(false), numModifiedRows(false) {} |
| bool operationState :1; |
| bool sqlState :1; |
| bool errorCode :1; |
| bool errorMessage :1; |
| bool taskStatus :1; |
| bool operationStarted :1; |
| bool operationCompleted :1; |
| bool hasResultSet :1; |
| bool progressUpdateResponse :1; |
| bool numModifiedRows :1; |
| } _TGetOperationStatusResp__isset; |
| |
| class TGetOperationStatusResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetOperationStatusResp(const TGetOperationStatusResp&); |
| TGetOperationStatusResp& operator=(const TGetOperationStatusResp&); |
| TGetOperationStatusResp() noexcept |
| : operationState(static_cast<TOperationState::type>(0)), |
| sqlState(), |
| errorCode(0), |
| errorMessage(), |
| taskStatus(), |
| operationStarted(0), |
| operationCompleted(0), |
| hasResultSet(0), |
| numModifiedRows(0) { |
| } |
| |
| virtual ~TGetOperationStatusResp() noexcept; |
| TStatus status; |
| /** |
| * |
| * @see TOperationState |
| */ |
| TOperationState::type operationState; |
| std::string sqlState; |
| int32_t errorCode; |
| std::string errorMessage; |
| std::string taskStatus; |
| int64_t operationStarted; |
| int64_t operationCompleted; |
| bool hasResultSet; |
| TProgressUpdateResp progressUpdateResponse; |
| int64_t numModifiedRows; |
| |
| _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); |
| |
| void __set_taskStatus(const std::string& val); |
| |
| void __set_operationStarted(const int64_t val); |
| |
| void __set_operationCompleted(const int64_t val); |
| |
| void __set_hasResultSet(const bool val); |
| |
| void __set_progressUpdateResponse(const TProgressUpdateResp& val); |
| |
| void __set_numModifiedRows(const int64_t 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; |
| if (__isset.taskStatus != rhs.__isset.taskStatus) |
| return false; |
| else if (__isset.taskStatus && !(taskStatus == rhs.taskStatus)) |
| return false; |
| if (__isset.operationStarted != rhs.__isset.operationStarted) |
| return false; |
| else if (__isset.operationStarted && !(operationStarted == rhs.operationStarted)) |
| return false; |
| if (__isset.operationCompleted != rhs.__isset.operationCompleted) |
| return false; |
| else if (__isset.operationCompleted && !(operationCompleted == rhs.operationCompleted)) |
| return false; |
| if (__isset.hasResultSet != rhs.__isset.hasResultSet) |
| return false; |
| else if (__isset.hasResultSet && !(hasResultSet == rhs.hasResultSet)) |
| return false; |
| if (__isset.progressUpdateResponse != rhs.__isset.progressUpdateResponse) |
| return false; |
| else if (__isset.progressUpdateResponse && !(progressUpdateResponse == rhs.progressUpdateResponse)) |
| return false; |
| if (__isset.numModifiedRows != rhs.__isset.numModifiedRows) |
| return false; |
| else if (__isset.numModifiedRows && !(numModifiedRows == rhs.numModifiedRows)) |
| 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) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetOperationStatusResp &a, TGetOperationStatusResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetOperationStatusResp& obj); |
| |
| |
| class TCancelOperationReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCancelOperationReq(const TCancelOperationReq&); |
| TCancelOperationReq& operator=(const TCancelOperationReq&); |
| TCancelOperationReq() noexcept { |
| } |
| |
| virtual ~TCancelOperationReq() noexcept; |
| TOperationHandle operationHandle; |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TCancelOperationReq & rhs) const |
| { |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| return true; |
| } |
| bool operator != (const TCancelOperationReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TCancelOperationReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCancelOperationReq &a, TCancelOperationReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCancelOperationReq& obj); |
| |
| |
| class TCancelOperationResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCancelOperationResp(const TCancelOperationResp&); |
| TCancelOperationResp& operator=(const TCancelOperationResp&); |
| TCancelOperationResp() noexcept { |
| } |
| |
| virtual ~TCancelOperationResp() noexcept; |
| TStatus status; |
| |
| void __set_status(const TStatus& val); |
| |
| bool operator == (const TCancelOperationResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| return true; |
| } |
| bool operator != (const TCancelOperationResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TCancelOperationResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCancelOperationResp &a, TCancelOperationResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCancelOperationResp& obj); |
| |
| |
| class TCloseOperationReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCloseOperationReq(const TCloseOperationReq&); |
| TCloseOperationReq& operator=(const TCloseOperationReq&); |
| TCloseOperationReq() noexcept { |
| } |
| |
| virtual ~TCloseOperationReq() noexcept; |
| TOperationHandle operationHandle; |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TCloseOperationReq & rhs) const |
| { |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| return true; |
| } |
| bool operator != (const TCloseOperationReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TCloseOperationReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCloseOperationReq &a, TCloseOperationReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCloseOperationReq& obj); |
| |
| |
| class TCloseOperationResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCloseOperationResp(const TCloseOperationResp&); |
| TCloseOperationResp& operator=(const TCloseOperationResp&); |
| TCloseOperationResp() noexcept { |
| } |
| |
| virtual ~TCloseOperationResp() noexcept; |
| TStatus status; |
| |
| void __set_status(const TStatus& val); |
| |
| bool operator == (const TCloseOperationResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| return true; |
| } |
| bool operator != (const TCloseOperationResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TCloseOperationResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCloseOperationResp &a, TCloseOperationResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCloseOperationResp& obj); |
| |
| |
| class TGetResultSetMetadataReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetResultSetMetadataReq(const TGetResultSetMetadataReq&); |
| TGetResultSetMetadataReq& operator=(const TGetResultSetMetadataReq&); |
| TGetResultSetMetadataReq() noexcept { |
| } |
| |
| virtual ~TGetResultSetMetadataReq() noexcept; |
| TOperationHandle operationHandle; |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TGetResultSetMetadataReq & rhs) const |
| { |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetResultSetMetadataReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetResultSetMetadataReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetResultSetMetadataReq &a, TGetResultSetMetadataReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetResultSetMetadataReq& obj); |
| |
| typedef struct _TGetResultSetMetadataResp__isset { |
| _TGetResultSetMetadataResp__isset() : schema(false) {} |
| bool schema :1; |
| } _TGetResultSetMetadataResp__isset; |
| |
| class TGetResultSetMetadataResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetResultSetMetadataResp(const TGetResultSetMetadataResp&); |
| TGetResultSetMetadataResp& operator=(const TGetResultSetMetadataResp&); |
| TGetResultSetMetadataResp() noexcept { |
| } |
| |
| virtual ~TGetResultSetMetadataResp() noexcept; |
| TStatus status; |
| TTableSchema schema; |
| |
| _TGetResultSetMetadataResp__isset __isset; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_schema(const TTableSchema& val); |
| |
| bool operator == (const TGetResultSetMetadataResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| if (__isset.schema != rhs.__isset.schema) |
| return false; |
| else if (__isset.schema && !(schema == rhs.schema)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetResultSetMetadataResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetResultSetMetadataResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetResultSetMetadataResp &a, TGetResultSetMetadataResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetResultSetMetadataResp& obj); |
| |
| typedef struct _TFetchResultsReq__isset { |
| _TFetchResultsReq__isset() : fetchType(true) {} |
| bool fetchType :1; |
| } _TFetchResultsReq__isset; |
| |
| class TFetchResultsReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TFetchResultsReq(const TFetchResultsReq&); |
| TFetchResultsReq& operator=(const TFetchResultsReq&); |
| TFetchResultsReq() noexcept |
| : orientation((TFetchOrientation::type)0), |
| maxRows(0), |
| fetchType(0) { |
| orientation = (TFetchOrientation::type)0; |
| |
| } |
| |
| virtual ~TFetchResultsReq() noexcept; |
| TOperationHandle operationHandle; |
| /** |
| * |
| * @see TFetchOrientation |
| */ |
| TFetchOrientation::type orientation; |
| int64_t maxRows; |
| int16_t fetchType; |
| |
| _TFetchResultsReq__isset __isset; |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| void __set_orientation(const TFetchOrientation::type val); |
| |
| void __set_maxRows(const int64_t val); |
| |
| void __set_fetchType(const int16_t val); |
| |
| bool operator == (const TFetchResultsReq & rhs) const |
| { |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| if (!(orientation == rhs.orientation)) |
| return false; |
| if (!(maxRows == rhs.maxRows)) |
| return false; |
| if (__isset.fetchType != rhs.__isset.fetchType) |
| return false; |
| else if (__isset.fetchType && !(fetchType == rhs.fetchType)) |
| return false; |
| return true; |
| } |
| bool operator != (const TFetchResultsReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TFetchResultsReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TFetchResultsReq &a, TFetchResultsReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TFetchResultsReq& obj); |
| |
| typedef struct _TFetchResultsResp__isset { |
| _TFetchResultsResp__isset() : hasMoreRows(false), results(false) {} |
| bool hasMoreRows :1; |
| bool results :1; |
| } _TFetchResultsResp__isset; |
| |
| class TFetchResultsResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TFetchResultsResp(const TFetchResultsResp&); |
| TFetchResultsResp& operator=(const TFetchResultsResp&); |
| TFetchResultsResp() noexcept |
| : hasMoreRows(0) { |
| } |
| |
| virtual ~TFetchResultsResp() noexcept; |
| TStatus status; |
| bool hasMoreRows; |
| TRowSet results; |
| |
| _TFetchResultsResp__isset __isset; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_hasMoreRows(const bool val); |
| |
| void __set_results(const TRowSet& val); |
| |
| bool operator == (const TFetchResultsResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| if (__isset.hasMoreRows != rhs.__isset.hasMoreRows) |
| return false; |
| else if (__isset.hasMoreRows && !(hasMoreRows == rhs.hasMoreRows)) |
| return false; |
| if (__isset.results != rhs.__isset.results) |
| return false; |
| else if (__isset.results && !(results == rhs.results)) |
| return false; |
| return true; |
| } |
| bool operator != (const TFetchResultsResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TFetchResultsResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TFetchResultsResp &a, TFetchResultsResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TFetchResultsResp& obj); |
| |
| |
| class TGetDelegationTokenReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetDelegationTokenReq(const TGetDelegationTokenReq&); |
| TGetDelegationTokenReq& operator=(const TGetDelegationTokenReq&); |
| TGetDelegationTokenReq() noexcept |
| : owner(), |
| renewer() { |
| } |
| |
| virtual ~TGetDelegationTokenReq() noexcept; |
| TSessionHandle sessionHandle; |
| std::string owner; |
| std::string renewer; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_owner(const std::string& val); |
| |
| void __set_renewer(const std::string& val); |
| |
| bool operator == (const TGetDelegationTokenReq & rhs) const |
| { |
| if (!(sessionHandle == rhs.sessionHandle)) |
| return false; |
| if (!(owner == rhs.owner)) |
| return false; |
| if (!(renewer == rhs.renewer)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetDelegationTokenReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetDelegationTokenReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetDelegationTokenReq &a, TGetDelegationTokenReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetDelegationTokenReq& obj); |
| |
| typedef struct _TGetDelegationTokenResp__isset { |
| _TGetDelegationTokenResp__isset() : delegationToken(false) {} |
| bool delegationToken :1; |
| } _TGetDelegationTokenResp__isset; |
| |
| class TGetDelegationTokenResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetDelegationTokenResp(const TGetDelegationTokenResp&); |
| TGetDelegationTokenResp& operator=(const TGetDelegationTokenResp&); |
| TGetDelegationTokenResp() noexcept |
| : delegationToken() { |
| } |
| |
| virtual ~TGetDelegationTokenResp() noexcept; |
| TStatus status; |
| std::string delegationToken; |
| |
| _TGetDelegationTokenResp__isset __isset; |
| |
| void __set_status(const TStatus& val); |
| |
| void __set_delegationToken(const std::string& val); |
| |
| bool operator == (const TGetDelegationTokenResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| if (__isset.delegationToken != rhs.__isset.delegationToken) |
| return false; |
| else if (__isset.delegationToken && !(delegationToken == rhs.delegationToken)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetDelegationTokenResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetDelegationTokenResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetDelegationTokenResp &a, TGetDelegationTokenResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetDelegationTokenResp& obj); |
| |
| |
| class TCancelDelegationTokenReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCancelDelegationTokenReq(const TCancelDelegationTokenReq&); |
| TCancelDelegationTokenReq& operator=(const TCancelDelegationTokenReq&); |
| TCancelDelegationTokenReq() noexcept |
| : delegationToken() { |
| } |
| |
| virtual ~TCancelDelegationTokenReq() noexcept; |
| TSessionHandle sessionHandle; |
| std::string delegationToken; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_delegationToken(const std::string& val); |
| |
| bool operator == (const TCancelDelegationTokenReq & rhs) const |
| { |
| if (!(sessionHandle == rhs.sessionHandle)) |
| return false; |
| if (!(delegationToken == rhs.delegationToken)) |
| return false; |
| return true; |
| } |
| bool operator != (const TCancelDelegationTokenReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TCancelDelegationTokenReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCancelDelegationTokenReq &a, TCancelDelegationTokenReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCancelDelegationTokenReq& obj); |
| |
| |
| class TCancelDelegationTokenResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TCancelDelegationTokenResp(const TCancelDelegationTokenResp&); |
| TCancelDelegationTokenResp& operator=(const TCancelDelegationTokenResp&); |
| TCancelDelegationTokenResp() noexcept { |
| } |
| |
| virtual ~TCancelDelegationTokenResp() noexcept; |
| TStatus status; |
| |
| void __set_status(const TStatus& val); |
| |
| bool operator == (const TCancelDelegationTokenResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| return true; |
| } |
| bool operator != (const TCancelDelegationTokenResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TCancelDelegationTokenResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TCancelDelegationTokenResp &a, TCancelDelegationTokenResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TCancelDelegationTokenResp& obj); |
| |
| |
| class TRenewDelegationTokenReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TRenewDelegationTokenReq(const TRenewDelegationTokenReq&); |
| TRenewDelegationTokenReq& operator=(const TRenewDelegationTokenReq&); |
| TRenewDelegationTokenReq() noexcept |
| : delegationToken() { |
| } |
| |
| virtual ~TRenewDelegationTokenReq() noexcept; |
| TSessionHandle sessionHandle; |
| std::string delegationToken; |
| |
| void __set_sessionHandle(const TSessionHandle& val); |
| |
| void __set_delegationToken(const std::string& val); |
| |
| bool operator == (const TRenewDelegationTokenReq & rhs) const |
| { |
| if (!(sessionHandle == rhs.sessionHandle)) |
| return false; |
| if (!(delegationToken == rhs.delegationToken)) |
| return false; |
| return true; |
| } |
| bool operator != (const TRenewDelegationTokenReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TRenewDelegationTokenReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TRenewDelegationTokenReq &a, TRenewDelegationTokenReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TRenewDelegationTokenReq& obj); |
| |
| |
| class TRenewDelegationTokenResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TRenewDelegationTokenResp(const TRenewDelegationTokenResp&); |
| TRenewDelegationTokenResp& operator=(const TRenewDelegationTokenResp&); |
| TRenewDelegationTokenResp() noexcept { |
| } |
| |
| virtual ~TRenewDelegationTokenResp() noexcept; |
| TStatus status; |
| |
| void __set_status(const TStatus& val); |
| |
| bool operator == (const TRenewDelegationTokenResp & rhs) const |
| { |
| if (!(status == rhs.status)) |
| return false; |
| return true; |
| } |
| bool operator != (const TRenewDelegationTokenResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TRenewDelegationTokenResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TRenewDelegationTokenResp &a, TRenewDelegationTokenResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TRenewDelegationTokenResp& obj); |
| |
| |
| class TProgressUpdateResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TProgressUpdateResp(const TProgressUpdateResp&); |
| TProgressUpdateResp& operator=(const TProgressUpdateResp&); |
| TProgressUpdateResp() noexcept |
| : progressedPercentage(0), |
| status(static_cast<TJobExecutionStatus::type>(0)), |
| footerSummary(), |
| startTime(0) { |
| } |
| |
| virtual ~TProgressUpdateResp() noexcept; |
| std::vector<std::string> headerNames; |
| std::vector<std::vector<std::string> > rows; |
| double progressedPercentage; |
| /** |
| * |
| * @see TJobExecutionStatus |
| */ |
| TJobExecutionStatus::type status; |
| std::string footerSummary; |
| int64_t startTime; |
| |
| void __set_headerNames(const std::vector<std::string> & val); |
| |
| void __set_rows(const std::vector<std::vector<std::string> > & val); |
| |
| void __set_progressedPercentage(const double val); |
| |
| void __set_status(const TJobExecutionStatus::type val); |
| |
| void __set_footerSummary(const std::string& val); |
| |
| void __set_startTime(const int64_t val); |
| |
| bool operator == (const TProgressUpdateResp & rhs) const |
| { |
| if (!(headerNames == rhs.headerNames)) |
| return false; |
| if (!(rows == rhs.rows)) |
| return false; |
| if (!(progressedPercentage == rhs.progressedPercentage)) |
| return false; |
| if (!(status == rhs.status)) |
| return false; |
| if (!(footerSummary == rhs.footerSummary)) |
| return false; |
| if (!(startTime == rhs.startTime)) |
| return false; |
| return true; |
| } |
| bool operator != (const TProgressUpdateResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TProgressUpdateResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TProgressUpdateResp &a, TProgressUpdateResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TProgressUpdateResp& obj); |
| |
| |
| class TGetQueryIdReq : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetQueryIdReq(const TGetQueryIdReq&); |
| TGetQueryIdReq& operator=(const TGetQueryIdReq&); |
| TGetQueryIdReq() noexcept { |
| } |
| |
| virtual ~TGetQueryIdReq() noexcept; |
| TOperationHandle operationHandle; |
| |
| void __set_operationHandle(const TOperationHandle& val); |
| |
| bool operator == (const TGetQueryIdReq & rhs) const |
| { |
| if (!(operationHandle == rhs.operationHandle)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetQueryIdReq &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetQueryIdReq & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetQueryIdReq &a, TGetQueryIdReq &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetQueryIdReq& obj); |
| |
| |
| class TGetQueryIdResp : public virtual ::apache::thrift::TBase { |
| public: |
| |
| TGetQueryIdResp(const TGetQueryIdResp&); |
| TGetQueryIdResp& operator=(const TGetQueryIdResp&); |
| TGetQueryIdResp() noexcept |
| : queryId() { |
| } |
| |
| virtual ~TGetQueryIdResp() noexcept; |
| std::string queryId; |
| |
| void __set_queryId(const std::string& val); |
| |
| bool operator == (const TGetQueryIdResp & rhs) const |
| { |
| if (!(queryId == rhs.queryId)) |
| return false; |
| return true; |
| } |
| bool operator != (const TGetQueryIdResp &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const TGetQueryIdResp & ) const; |
| |
| uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override; |
| uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(TGetQueryIdResp &a, TGetQueryIdResp &b); |
| |
| std::ostream& operator<<(std::ostream& out, const TGetQueryIdResp& obj); |
| |
| }}}}} // namespace |
| |
| #endif |