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

<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 100 of 102 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedJan 8, '16 at 12:19a
activeJan 11, '16 at 8:25a
posts102
users1
websitehive.apache.org

1 user in discussion

Vgumashta: 102 posts

People

Translate

site design / logo © 2021 Grokbase