http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/service/src/gen/thrift/gen-cpp/TCLIService_types.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_types.h b/service/src/gen/thrift/gen-cpp/TCLIService_types.h index 7bceabd..4536b41 100644 --- a/service/src/gen/thrift/gen-cpp/TCLIService_types.h +++ b/service/src/gen/thrift/gen-cpp/TCLIService_types.h @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.0) + * Autogenerated by Thrift Compiler (0.9.2) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -7,11 +7,14 @@ #ifndef TCLIService_TYPES_H #define TCLIService_TYPES_H +#include <iosfwd> + #include <thrift/Thrift.h> #include <thrift/TApplicationException.h> #include <thrift/protocol/TProtocol.h> #include <thrift/transport/TTransport.h> +#include <thrift/cxxfunctional.h> namespace apache { namespace hive { namespace service { namespace cli { namespace thrift { @@ -178,10 +181,158 @@ 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; - bool stringValue; + bool i32Value :1; + bool stringValue :1; } _TTypeQualifierValue__isset; class TTypeQualifierValue { @@ -190,25 +341,20 @@ class TTypeQualifierValue { static const char* ascii_fingerprint; // = "A7801670116150C65ACA43E6F679BA79"; static const uint8_t binary_fingerprint[16]; // = {0xA7,0x80,0x16,0x70,0x11,0x61,0x50,0xC6,0x5A,0xCA,0x43,0xE6,0xF6,0x79,0xBA,0x79}; + TTypeQualifierValue(const TTypeQualifierValue&); + TTypeQualifierValue& operator=(const TTypeQualifierValue&); TTypeQualifierValue() : i32Value(0), stringValue() { } - virtual ~TTypeQualifierValue() throw() {} - + virtual ~TTypeQualifierValue() throw(); int32_t i32Value; std::string stringValue; _TTypeQualifierValue__isset __isset; - void __set_i32Value(const int32_t val) { - i32Value = val; - __isset.i32Value = true; - } + void __set_i32Value(const int32_t val); - void __set_stringValue(const std::string& val) { - stringValue = val; - __isset.stringValue = true; - } + void __set_stringValue(const std::string& val); bool operator == (const TTypeQualifierValue & rhs) const { @@ -231,6 +377,7 @@ class TTypeQualifierValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj); }; void swap(TTypeQualifierValue &a, TTypeQualifierValue &b); @@ -242,16 +389,15 @@ class TTypeQualifiers { static const char* ascii_fingerprint; // = "6C72981CFA989214285648FA8C196C47"; static const uint8_t binary_fingerprint[16]; // = {0x6C,0x72,0x98,0x1C,0xFA,0x98,0x92,0x14,0x28,0x56,0x48,0xFA,0x8C,0x19,0x6C,0x47}; + TTypeQualifiers(const TTypeQualifiers&); + TTypeQualifiers& operator=(const TTypeQualifiers&); TTypeQualifiers() { } - virtual ~TTypeQualifiers() throw() {} - + virtual ~TTypeQualifiers() throw(); std::map<std::string, TTypeQualifierValue> qualifiers; - void __set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val) { - qualifiers = val; - } + void __set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val); bool operator == (const TTypeQualifiers & rhs) const { @@ -268,13 +414,14 @@ class TTypeQualifiers { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj); }; void swap(TTypeQualifiers &a, TTypeQualifiers &b); typedef struct _TPrimitiveTypeEntry__isset { _TPrimitiveTypeEntry__isset() : typeQualifiers(false) {} - bool typeQualifiers; + bool typeQualifiers :1; } _TPrimitiveTypeEntry__isset; class TPrimitiveTypeEntry { @@ -283,24 +430,20 @@ class TPrimitiveTypeEntry { static const char* ascii_fingerprint; // = "755674F6A5C8EB47868686AE386FBC1C"; static const uint8_t binary_fingerprint[16]; // = {0x75,0x56,0x74,0xF6,0xA5,0xC8,0xEB,0x47,0x86,0x86,0x86,0xAE,0x38,0x6F,0xBC,0x1C}; + TPrimitiveTypeEntry(const TPrimitiveTypeEntry&); + TPrimitiveTypeEntry& operator=(const TPrimitiveTypeEntry&); TPrimitiveTypeEntry() : type((TTypeId::type)0) { } - virtual ~TPrimitiveTypeEntry() throw() {} - + virtual ~TPrimitiveTypeEntry() throw(); TTypeId::type type; TTypeQualifiers typeQualifiers; _TPrimitiveTypeEntry__isset __isset; - void __set_type(const TTypeId::type val) { - type = val; - } + void __set_type(const TTypeId::type val); - void __set_typeQualifiers(const TTypeQualifiers& val) { - typeQualifiers = val; - __isset.typeQualifiers = true; - } + void __set_typeQualifiers(const TTypeQualifiers& val); bool operator == (const TPrimitiveTypeEntry & rhs) const { @@ -321,6 +464,7 @@ class TPrimitiveTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj); }; void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b); @@ -332,16 +476,15 @@ class TArrayTypeEntry { static const char* ascii_fingerprint; // = "E86CACEB22240450EDCBEFC3A83970E4"; static const uint8_t binary_fingerprint[16]; // = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4}; + TArrayTypeEntry(const TArrayTypeEntry&); + TArrayTypeEntry& operator=(const TArrayTypeEntry&); TArrayTypeEntry() : objectTypePtr(0) { } - virtual ~TArrayTypeEntry() throw() {} - + virtual ~TArrayTypeEntry() throw(); TTypeEntryPtr objectTypePtr; - void __set_objectTypePtr(const TTypeEntryPtr val) { - objectTypePtr = val; - } + void __set_objectTypePtr(const TTypeEntryPtr val); bool operator == (const TArrayTypeEntry & rhs) const { @@ -358,6 +501,7 @@ class TArrayTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj); }; void swap(TArrayTypeEntry &a, TArrayTypeEntry &b); @@ -369,21 +513,18 @@ class TMapTypeEntry { static const char* ascii_fingerprint; // = "989D1F1AE8D148D5E2119FFEC4BBBEE3"; static const uint8_t binary_fingerprint[16]; // = {0x98,0x9D,0x1F,0x1A,0xE8,0xD1,0x48,0xD5,0xE2,0x11,0x9F,0xFE,0xC4,0xBB,0xBE,0xE3}; + TMapTypeEntry(const TMapTypeEntry&); + TMapTypeEntry& operator=(const TMapTypeEntry&); TMapTypeEntry() : keyTypePtr(0), valueTypePtr(0) { } - virtual ~TMapTypeEntry() throw() {} - + virtual ~TMapTypeEntry() throw(); TTypeEntryPtr keyTypePtr; TTypeEntryPtr valueTypePtr; - void __set_keyTypePtr(const TTypeEntryPtr val) { - keyTypePtr = val; - } + void __set_keyTypePtr(const TTypeEntryPtr val); - void __set_valueTypePtr(const TTypeEntryPtr val) { - valueTypePtr = val; - } + void __set_valueTypePtr(const TTypeEntryPtr val); bool operator == (const TMapTypeEntry & rhs) const { @@ -402,6 +543,7 @@ class TMapTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj); }; void swap(TMapTypeEntry &a, TMapTypeEntry &b); @@ -413,16 +555,15 @@ class TStructTypeEntry { static const char* ascii_fingerprint; // = "91F548CA159B4AB4291F5741AC161402"; static const uint8_t binary_fingerprint[16]; // = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02}; + TStructTypeEntry(const TStructTypeEntry&); + TStructTypeEntry& operator=(const TStructTypeEntry&); TStructTypeEntry() { } - virtual ~TStructTypeEntry() throw() {} - + virtual ~TStructTypeEntry() throw(); std::map<std::string, TTypeEntryPtr> nameToTypePtr; - void __set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) { - nameToTypePtr = val; - } + void __set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val); bool operator == (const TStructTypeEntry & rhs) const { @@ -439,6 +580,7 @@ class TStructTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj); }; void swap(TStructTypeEntry &a, TStructTypeEntry &b); @@ -450,16 +592,15 @@ class TUnionTypeEntry { static const char* ascii_fingerprint; // = "91F548CA159B4AB4291F5741AC161402"; static const uint8_t binary_fingerprint[16]; // = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02}; + TUnionTypeEntry(const TUnionTypeEntry&); + TUnionTypeEntry& operator=(const TUnionTypeEntry&); TUnionTypeEntry() { } - virtual ~TUnionTypeEntry() throw() {} - + virtual ~TUnionTypeEntry() throw(); std::map<std::string, TTypeEntryPtr> nameToTypePtr; - void __set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) { - nameToTypePtr = val; - } + void __set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val); bool operator == (const TUnionTypeEntry & rhs) const { @@ -476,6 +617,7 @@ class TUnionTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj); }; void swap(TUnionTypeEntry &a, TUnionTypeEntry &b); @@ -487,16 +629,15 @@ class TUserDefinedTypeEntry { static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + TUserDefinedTypeEntry(const TUserDefinedTypeEntry&); + TUserDefinedTypeEntry& operator=(const TUserDefinedTypeEntry&); TUserDefinedTypeEntry() : typeClassName() { } - virtual ~TUserDefinedTypeEntry() throw() {} - + virtual ~TUserDefinedTypeEntry() throw(); std::string typeClassName; - void __set_typeClassName(const std::string& val) { - typeClassName = val; - } + void __set_typeClassName(const std::string& val); bool operator == (const TUserDefinedTypeEntry & rhs) const { @@ -513,18 +654,19 @@ class TUserDefinedTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj); }; void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b); typedef struct _TTypeEntry__isset { _TTypeEntry__isset() : primitiveEntry(false), arrayEntry(false), mapEntry(false), structEntry(false), unionEntry(false), userDefinedTypeEntry(false) {} - bool primitiveEntry; - bool arrayEntry; - bool mapEntry; - bool structEntry; - bool unionEntry; - bool userDefinedTypeEntry; + bool primitiveEntry :1; + bool arrayEntry :1; + bool mapEntry :1; + bool structEntry :1; + bool unionEntry :1; + bool userDefinedTypeEntry :1; } _TTypeEntry__isset; class TTypeEntry { @@ -533,11 +675,12 @@ class TTypeEntry { static const char* ascii_fingerprint; // = "2FE56D9097E325DAA7E933738C6D325F"; static const uint8_t binary_fingerprint[16]; // = {0x2F,0xE5,0x6D,0x90,0x97,0xE3,0x25,0xDA,0xA7,0xE9,0x33,0x73,0x8C,0x6D,0x32,0x5F}; + TTypeEntry(const TTypeEntry&); + TTypeEntry& operator=(const TTypeEntry&); TTypeEntry() { } - virtual ~TTypeEntry() throw() {} - + virtual ~TTypeEntry() throw(); TPrimitiveTypeEntry primitiveEntry; TArrayTypeEntry arrayEntry; TMapTypeEntry mapEntry; @@ -547,29 +690,17 @@ class TTypeEntry { _TTypeEntry__isset __isset; - void __set_primitiveEntry(const TPrimitiveTypeEntry& val) { - primitiveEntry = val; - } + void __set_primitiveEntry(const TPrimitiveTypeEntry& val); - void __set_arrayEntry(const TArrayTypeEntry& val) { - arrayEntry = val; - } + void __set_arrayEntry(const TArrayTypeEntry& val); - void __set_mapEntry(const TMapTypeEntry& val) { - mapEntry = val; - } + void __set_mapEntry(const TMapTypeEntry& val); - void __set_structEntry(const TStructTypeEntry& val) { - structEntry = val; - } + void __set_structEntry(const TStructTypeEntry& val); - void __set_unionEntry(const TUnionTypeEntry& val) { - unionEntry = val; - } + void __set_unionEntry(const TUnionTypeEntry& val); - void __set_userDefinedTypeEntry(const TUserDefinedTypeEntry& val) { - userDefinedTypeEntry = val; - } + void __set_userDefinedTypeEntry(const TUserDefinedTypeEntry& val); bool operator == (const TTypeEntry & rhs) const { @@ -596,6 +727,7 @@ class TTypeEntry { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj); }; void swap(TTypeEntry &a, TTypeEntry &b); @@ -607,16 +739,15 @@ class TTypeDesc { static const char* ascii_fingerprint; // = "90B3C5A0B73419A84E85E0E48C452AA5"; static const uint8_t binary_fingerprint[16]; // = {0x90,0xB3,0xC5,0xA0,0xB7,0x34,0x19,0xA8,0x4E,0x85,0xE0,0xE4,0x8C,0x45,0x2A,0xA5}; + TTypeDesc(const TTypeDesc&); + TTypeDesc& operator=(const TTypeDesc&); TTypeDesc() { } - virtual ~TTypeDesc() throw() {} - + virtual ~TTypeDesc() throw(); std::vector<TTypeEntry> types; - void __set_types(const std::vector<TTypeEntry> & val) { - types = val; - } + void __set_types(const std::vector<TTypeEntry> & val); bool operator == (const TTypeDesc & rhs) const { @@ -633,13 +764,14 @@ class TTypeDesc { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj); }; void swap(TTypeDesc &a, TTypeDesc &b); typedef struct _TColumnDesc__isset { _TColumnDesc__isset() : comment(false) {} - bool comment; + bool comment :1; } _TColumnDesc__isset; class TColumnDesc { @@ -648,11 +780,12 @@ class TColumnDesc { static const char* ascii_fingerprint; // = "EABED9009D5FCABFCA65612069F2A849"; static const uint8_t binary_fingerprint[16]; // = {0xEA,0xBE,0xD9,0x00,0x9D,0x5F,0xCA,0xBF,0xCA,0x65,0x61,0x20,0x69,0xF2,0xA8,0x49}; + TColumnDesc(const TColumnDesc&); + TColumnDesc& operator=(const TColumnDesc&); TColumnDesc() : columnName(), position(0), comment() { } - virtual ~TColumnDesc() throw() {} - + virtual ~TColumnDesc() throw(); std::string columnName; TTypeDesc typeDesc; int32_t position; @@ -660,22 +793,13 @@ class TColumnDesc { _TColumnDesc__isset __isset; - void __set_columnName(const std::string& val) { - columnName = val; - } + void __set_columnName(const std::string& val); - void __set_typeDesc(const TTypeDesc& val) { - typeDesc = val; - } + void __set_typeDesc(const TTypeDesc& val); - void __set_position(const int32_t val) { - position = val; - } + void __set_position(const int32_t val); - void __set_comment(const std::string& val) { - comment = val; - __isset.comment = true; - } + void __set_comment(const std::string& val); bool operator == (const TColumnDesc & rhs) const { @@ -700,6 +824,7 @@ class TColumnDesc { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj); }; void swap(TColumnDesc &a, TColumnDesc &b); @@ -711,16 +836,15 @@ class TTableSchema { static const char* ascii_fingerprint; // = "7A1811E49313E5977107FC667B20E39D"; static const uint8_t binary_fingerprint[16]; // = {0x7A,0x18,0x11,0xE4,0x93,0x13,0xE5,0x97,0x71,0x07,0xFC,0x66,0x7B,0x20,0xE3,0x9D}; + TTableSchema(const TTableSchema&); + TTableSchema& operator=(const TTableSchema&); TTableSchema() { } - virtual ~TTableSchema() throw() {} - + virtual ~TTableSchema() throw(); std::vector<TColumnDesc> columns; - void __set_columns(const std::vector<TColumnDesc> & val) { - columns = val; - } + void __set_columns(const std::vector<TColumnDesc> & val); bool operator == (const TTableSchema & rhs) const { @@ -737,13 +861,14 @@ class TTableSchema { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TTableSchema& obj); }; void swap(TTableSchema &a, TTableSchema &b); typedef struct _TBoolValue__isset { _TBoolValue__isset() : value(false) {} - bool value; + bool value :1; } _TBoolValue__isset; class TBoolValue { @@ -752,19 +877,17 @@ class TBoolValue { static const char* ascii_fingerprint; // = "BF054652DEF86253C2BEE7D947F167DD"; static const uint8_t binary_fingerprint[16]; // = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD}; + TBoolValue(const TBoolValue&); + TBoolValue& operator=(const TBoolValue&); TBoolValue() : value(0) { } - virtual ~TBoolValue() throw() {} - + virtual ~TBoolValue() throw(); bool value; _TBoolValue__isset __isset; - void __set_value(const bool val) { - value = val; - __isset.value = true; - } + void __set_value(const bool val); bool operator == (const TBoolValue & rhs) const { @@ -783,13 +906,14 @@ class TBoolValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TBoolValue& obj); }; void swap(TBoolValue &a, TBoolValue &b); typedef struct _TByteValue__isset { _TByteValue__isset() : value(false) {} - bool value; + bool value :1; } _TByteValue__isset; class TByteValue { @@ -798,19 +922,17 @@ class TByteValue { static const char* ascii_fingerprint; // = "9C15298ACB5D04AEA9B52D5DDE6F9208"; static const uint8_t binary_fingerprint[16]; // = {0x9C,0x15,0x29,0x8A,0xCB,0x5D,0x04,0xAE,0xA9,0xB5,0x2D,0x5D,0xDE,0x6F,0x92,0x08}; + TByteValue(const TByteValue&); + TByteValue& operator=(const TByteValue&); TByteValue() : value(0) { } - virtual ~TByteValue() throw() {} - + virtual ~TByteValue() throw(); int8_t value; _TByteValue__isset __isset; - void __set_value(const int8_t val) { - value = val; - __isset.value = true; - } + void __set_value(const int8_t val); bool operator == (const TByteValue & rhs) const { @@ -829,13 +951,14 @@ class TByteValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TByteValue& obj); }; void swap(TByteValue &a, TByteValue &b); typedef struct _TI16Value__isset { _TI16Value__isset() : value(false) {} - bool value; + bool value :1; } _TI16Value__isset; class TI16Value { @@ -844,19 +967,17 @@ class TI16Value { static const char* ascii_fingerprint; // = "5DAC9C51C7E1106BF936FC71860BE9D5"; static const uint8_t binary_fingerprint[16]; // = {0x5D,0xAC,0x9C,0x51,0xC7,0xE1,0x10,0x6B,0xF9,0x36,0xFC,0x71,0x86,0x0B,0xE9,0xD5}; + TI16Value(const TI16Value&); + TI16Value& operator=(const TI16Value&); TI16Value() : value(0) { } - virtual ~TI16Value() throw() {} - + virtual ~TI16Value() throw(); int16_t value; _TI16Value__isset __isset; - void __set_value(const int16_t val) { - value = val; - __isset.value = true; - } + void __set_value(const int16_t val); bool operator == (const TI16Value & rhs) const { @@ -875,13 +996,14 @@ class TI16Value { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TI16Value& obj); }; void swap(TI16Value &a, TI16Value &b); typedef struct _TI32Value__isset { _TI32Value__isset() : value(false) {} - bool value; + bool value :1; } _TI32Value__isset; class TI32Value { @@ -890,19 +1012,17 @@ class TI32Value { static const char* ascii_fingerprint; // = "E7A96B151330359E84C0A3AC91BCBACD"; static const uint8_t binary_fingerprint[16]; // = {0xE7,0xA9,0x6B,0x15,0x13,0x30,0x35,0x9E,0x84,0xC0,0xA3,0xAC,0x91,0xBC,0xBA,0xCD}; + TI32Value(const TI32Value&); + TI32Value& operator=(const TI32Value&); TI32Value() : value(0) { } - virtual ~TI32Value() throw() {} - + virtual ~TI32Value() throw(); int32_t value; _TI32Value__isset __isset; - void __set_value(const int32_t val) { - value = val; - __isset.value = true; - } + void __set_value(const int32_t val); bool operator == (const TI32Value & rhs) const { @@ -921,13 +1041,14 @@ class TI32Value { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TI32Value& obj); }; void swap(TI32Value &a, TI32Value &b); typedef struct _TI64Value__isset { _TI64Value__isset() : value(false) {} - bool value; + bool value :1; } _TI64Value__isset; class TI64Value { @@ -936,19 +1057,17 @@ class TI64Value { static const char* ascii_fingerprint; // = "148F3AAAC1D9859963D5E800D187BF26"; static const uint8_t binary_fingerprint[16]; // = {0x14,0x8F,0x3A,0xAA,0xC1,0xD9,0x85,0x99,0x63,0xD5,0xE8,0x00,0xD1,0x87,0xBF,0x26}; + TI64Value(const TI64Value&); + TI64Value& operator=(const TI64Value&); TI64Value() : value(0) { } - virtual ~TI64Value() throw() {} - + virtual ~TI64Value() throw(); int64_t value; _TI64Value__isset __isset; - void __set_value(const int64_t val) { - value = val; - __isset.value = true; - } + void __set_value(const int64_t val); bool operator == (const TI64Value & rhs) const { @@ -967,13 +1086,14 @@ class TI64Value { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TI64Value& obj); }; void swap(TI64Value &a, TI64Value &b); typedef struct _TDoubleValue__isset { _TDoubleValue__isset() : value(false) {} - bool value; + bool value :1; } _TDoubleValue__isset; class TDoubleValue { @@ -982,19 +1102,17 @@ class TDoubleValue { static const char* ascii_fingerprint; // = "3586E570A474C4A8603B4FF74903B3A6"; static const uint8_t binary_fingerprint[16]; // = {0x35,0x86,0xE5,0x70,0xA4,0x74,0xC4,0xA8,0x60,0x3B,0x4F,0xF7,0x49,0x03,0xB3,0xA6}; + TDoubleValue(const TDoubleValue&); + TDoubleValue& operator=(const TDoubleValue&); TDoubleValue() : value(0) { } - virtual ~TDoubleValue() throw() {} - + virtual ~TDoubleValue() throw(); double value; _TDoubleValue__isset __isset; - void __set_value(const double val) { - value = val; - __isset.value = true; - } + void __set_value(const double val); bool operator == (const TDoubleValue & rhs) const { @@ -1013,13 +1131,14 @@ class TDoubleValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj); }; void swap(TDoubleValue &a, TDoubleValue &b); typedef struct _TStringValue__isset { _TStringValue__isset() : value(false) {} - bool value; + bool value :1; } _TStringValue__isset; class TStringValue { @@ -1028,19 +1147,17 @@ class TStringValue { static const char* ascii_fingerprint; // = "66E694018C17E5B65A59AE8F55CCA3CD"; static const uint8_t binary_fingerprint[16]; // = {0x66,0xE6,0x94,0x01,0x8C,0x17,0xE5,0xB6,0x5A,0x59,0xAE,0x8F,0x55,0xCC,0xA3,0xCD}; + TStringValue(const TStringValue&); + TStringValue& operator=(const TStringValue&); TStringValue() : value() { } - virtual ~TStringValue() throw() {} - + virtual ~TStringValue() throw(); std::string value; _TStringValue__isset __isset; - void __set_value(const std::string& val) { - value = val; - __isset.value = true; - } + void __set_value(const std::string& val); bool operator == (const TStringValue & rhs) const { @@ -1059,19 +1176,20 @@ class TStringValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TStringValue& obj); }; void swap(TStringValue &a, TStringValue &b); typedef struct _TColumnValue__isset { _TColumnValue__isset() : boolVal(false), byteVal(false), i16Val(false), i32Val(false), i64Val(false), doubleVal(false), stringVal(false) {} - bool boolVal; - bool byteVal; - bool i16Val; - bool i32Val; - bool i64Val; - bool doubleVal; - bool stringVal; + 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 { @@ -1080,11 +1198,12 @@ class TColumnValue { static const char* ascii_fingerprint; // = "C2DDD988447EA7999A8285AA38AAE9AD"; static const uint8_t binary_fingerprint[16]; // = {0xC2,0xDD,0xD9,0x88,0x44,0x7E,0xA7,0x99,0x9A,0x82,0x85,0xAA,0x38,0xAA,0xE9,0xAD}; + TColumnValue(const TColumnValue&); + TColumnValue& operator=(const TColumnValue&); TColumnValue() { } - virtual ~TColumnValue() throw() {} - + virtual ~TColumnValue() throw(); TBoolValue boolVal; TByteValue byteVal; TI16Value i16Val; @@ -1095,33 +1214,19 @@ class TColumnValue { _TColumnValue__isset __isset; - void __set_boolVal(const TBoolValue& val) { - boolVal = val; - } + void __set_boolVal(const TBoolValue& val); - void __set_byteVal(const TByteValue& val) { - byteVal = val; - } + void __set_byteVal(const TByteValue& val); - void __set_i16Val(const TI16Value& val) { - i16Val = val; - } + void __set_i16Val(const TI16Value& val); - void __set_i32Val(const TI32Value& val) { - i32Val = val; - } + void __set_i32Val(const TI32Value& val); - void __set_i64Val(const TI64Value& val) { - i64Val = val; - } + void __set_i64Val(const TI64Value& val); - void __set_doubleVal(const TDoubleValue& val) { - doubleVal = val; - } + void __set_doubleVal(const TDoubleValue& val); - void __set_stringVal(const TStringValue& val) { - stringVal = val; - } + void __set_stringVal(const TStringValue& val); bool operator == (const TColumnValue & rhs) const { @@ -1150,6 +1255,7 @@ class TColumnValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TColumnValue& obj); }; void swap(TColumnValue &a, TColumnValue &b); @@ -1161,16 +1267,15 @@ class TRow { static const char* ascii_fingerprint; // = "E73FD1FCA0CA58A669FC3E02FB68D534"; static const uint8_t binary_fingerprint[16]; // = {0xE7,0x3F,0xD1,0xFC,0xA0,0xCA,0x58,0xA6,0x69,0xFC,0x3E,0x02,0xFB,0x68,0xD5,0x34}; + TRow(const TRow&); + TRow& operator=(const TRow&); TRow() { } - virtual ~TRow() throw() {} - + virtual ~TRow() throw(); std::vector<TColumnValue> colVals; - void __set_colVals(const std::vector<TColumnValue> & val) { - colVals = val; - } + void __set_colVals(const std::vector<TColumnValue> & val); bool operator == (const TRow & rhs) const { @@ -1187,6 +1292,7 @@ class TRow { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TRow& obj); }; void swap(TRow &a, TRow &b); @@ -1198,21 +1304,18 @@ class TBoolColumn { static const char* ascii_fingerprint; // = "F9058324D96DB7F974D8ACDC01C54219"; static const uint8_t binary_fingerprint[16]; // = {0xF9,0x05,0x83,0x24,0xD9,0x6D,0xB7,0xF9,0x74,0xD8,0xAC,0xDC,0x01,0xC5,0x42,0x19}; + TBoolColumn(const TBoolColumn&); + TBoolColumn& operator=(const TBoolColumn&); TBoolColumn() : nulls() { } - virtual ~TBoolColumn() throw() {} - + virtual ~TBoolColumn() throw(); std::vector<bool> values; std::string nulls; - void __set_values(const std::vector<bool> & val) { - values = val; - } + void __set_values(const std::vector<bool> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TBoolColumn & rhs) const { @@ -1231,6 +1334,7 @@ class TBoolColumn { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj); }; void swap(TBoolColumn &a, TBoolColumn &b); @@ -1242,21 +1346,18 @@ class TByteColumn { static const char* ascii_fingerprint; // = "1CB300106BAA463A70BB2A2395900F48"; static const uint8_t binary_fingerprint[16]; // = {0x1C,0xB3,0x00,0x10,0x6B,0xAA,0x46,0x3A,0x70,0xBB,0x2A,0x23,0x95,0x90,0x0F,0x48}; + TByteColumn(const TByteColumn&); + TByteColumn& operator=(const TByteColumn&); TByteColumn() : nulls() { } - virtual ~TByteColumn() throw() {} - + virtual ~TByteColumn() throw(); std::vector<int8_t> values; std::string nulls; - void __set_values(const std::vector<int8_t> & val) { - values = val; - } + void __set_values(const std::vector<int8_t> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TByteColumn & rhs) const { @@ -1275,6 +1376,7 @@ class TByteColumn { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TByteColumn& obj); }; void swap(TByteColumn &a, TByteColumn &b); @@ -1286,21 +1388,18 @@ class TI16Column { static const char* ascii_fingerprint; // = "6574CDB1F121C8DB47FB257A3F104BDB"; static const uint8_t binary_fingerprint[16]; // = {0x65,0x74,0xCD,0xB1,0xF1,0x21,0xC8,0xDB,0x47,0xFB,0x25,0x7A,0x3F,0x10,0x4B,0xDB}; + TI16Column(const TI16Column&); + TI16Column& operator=(const TI16Column&); TI16Column() : nulls() { } - virtual ~TI16Column() throw() {} - + virtual ~TI16Column() throw(); std::vector<int16_t> values; std::string nulls; - void __set_values(const std::vector<int16_t> & val) { - values = val; - } + void __set_values(const std::vector<int16_t> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TI16Column & rhs) const { @@ -1319,6 +1418,7 @@ class TI16Column { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TI16Column& obj); }; void swap(TI16Column &a, TI16Column &b); @@ -1330,21 +1430,18 @@ class TI32Column { static const char* ascii_fingerprint; // = "CCCCE89C7E9DA10280F5663700677313"; static const uint8_t binary_fingerprint[16]; // = {0xCC,0xCC,0xE8,0x9C,0x7E,0x9D,0xA1,0x02,0x80,0xF5,0x66,0x37,0x00,0x67,0x73,0x13}; + TI32Column(const TI32Column&); + TI32Column& operator=(const TI32Column&); TI32Column() : nulls() { } - virtual ~TI32Column() throw() {} - + virtual ~TI32Column() throw(); std::vector<int32_t> values; std::string nulls; - void __set_values(const std::vector<int32_t> & val) { - values = val; - } + void __set_values(const std::vector<int32_t> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TI32Column & rhs) const { @@ -1363,6 +1460,7 @@ class TI32Column { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TI32Column& obj); }; void swap(TI32Column &a, TI32Column &b); @@ -1374,21 +1472,18 @@ class TI64Column { static const char* ascii_fingerprint; // = "925353917FC0AF87976A2338011F5A31"; static const uint8_t binary_fingerprint[16]; // = {0x92,0x53,0x53,0x91,0x7F,0xC0,0xAF,0x87,0x97,0x6A,0x23,0x38,0x01,0x1F,0x5A,0x31}; + TI64Column(const TI64Column&); + TI64Column& operator=(const TI64Column&); TI64Column() : nulls() { } - virtual ~TI64Column() throw() {} - + virtual ~TI64Column() throw(); std::vector<int64_t> values; std::string nulls; - void __set_values(const std::vector<int64_t> & val) { - values = val; - } + void __set_values(const std::vector<int64_t> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TI64Column & rhs) const { @@ -1407,6 +1502,7 @@ class TI64Column { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TI64Column& obj); }; void swap(TI64Column &a, TI64Column &b); @@ -1418,21 +1514,18 @@ class TDoubleColumn { static const char* ascii_fingerprint; // = "8FF1C050A8D7FD247AEB23CD71539C09"; static const uint8_t binary_fingerprint[16]; // = {0x8F,0xF1,0xC0,0x50,0xA8,0xD7,0xFD,0x24,0x7A,0xEB,0x23,0xCD,0x71,0x53,0x9C,0x09}; + TDoubleColumn(const TDoubleColumn&); + TDoubleColumn& operator=(const TDoubleColumn&); TDoubleColumn() : nulls() { } - virtual ~TDoubleColumn() throw() {} - + virtual ~TDoubleColumn() throw(); std::vector<double> values; std::string nulls; - void __set_values(const std::vector<double> & val) { - values = val; - } + void __set_values(const std::vector<double> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TDoubleColumn & rhs) const { @@ -1451,6 +1544,7 @@ class TDoubleColumn { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj); }; void swap(TDoubleColumn &a, TDoubleColumn &b); @@ -1462,21 +1556,18 @@ class TStringColumn { static const char* ascii_fingerprint; // = "BE556BF7091B2DABBA1863D5E458B15F"; static const uint8_t binary_fingerprint[16]; // = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F}; + TStringColumn(const TStringColumn&); + TStringColumn& operator=(const TStringColumn&); TStringColumn() : nulls() { } - virtual ~TStringColumn() throw() {} - + virtual ~TStringColumn() throw(); std::vector<std::string> values; std::string nulls; - void __set_values(const std::vector<std::string> & val) { - values = val; - } + void __set_values(const std::vector<std::string> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TStringColumn & rhs) const { @@ -1495,6 +1586,7 @@ class TStringColumn { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TStringColumn& obj); }; void swap(TStringColumn &a, TStringColumn &b); @@ -1506,21 +1598,18 @@ class TBinaryColumn { static const char* ascii_fingerprint; // = "BE556BF7091B2DABBA1863D5E458B15F"; static const uint8_t binary_fingerprint[16]; // = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F}; + TBinaryColumn(const TBinaryColumn&); + TBinaryColumn& operator=(const TBinaryColumn&); TBinaryColumn() : nulls() { } - virtual ~TBinaryColumn() throw() {} - + virtual ~TBinaryColumn() throw(); std::vector<std::string> values; std::string nulls; - void __set_values(const std::vector<std::string> & val) { - values = val; - } + void __set_values(const std::vector<std::string> & val); - void __set_nulls(const std::string& val) { - nulls = val; - } + void __set_nulls(const std::string& val); bool operator == (const TBinaryColumn & rhs) const { @@ -1539,20 +1628,21 @@ class TBinaryColumn { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj); }; void swap(TBinaryColumn &a, TBinaryColumn &b); typedef struct _TColumn__isset { _TColumn__isset() : boolVal(false), byteVal(false), i16Val(false), i32Val(false), i64Val(false), doubleVal(false), stringVal(false), binaryVal(false) {} - bool boolVal; - bool byteVal; - bool i16Val; - bool i32Val; - bool i64Val; - bool doubleVal; - bool stringVal; - bool binaryVal; + 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 { @@ -1561,11 +1651,12 @@ class TColumn { static const char* ascii_fingerprint; // = "E6ADD10B4CDDE61A19E8878CC7039A17"; static const uint8_t binary_fingerprint[16]; // = {0xE6,0xAD,0xD1,0x0B,0x4C,0xDD,0xE6,0x1A,0x19,0xE8,0x87,0x8C,0xC7,0x03,0x9A,0x17}; + TColumn(const TColumn&); + TColumn& operator=(const TColumn&); TColumn() { } - virtual ~TColumn() throw() {} - + virtual ~TColumn() throw(); TBoolColumn boolVal; TByteColumn byteVal; TI16Column i16Val; @@ -1577,37 +1668,21 @@ class TColumn { _TColumn__isset __isset; - void __set_boolVal(const TBoolColumn& val) { - boolVal = val; - } + void __set_boolVal(const TBoolColumn& val); - void __set_byteVal(const TByteColumn& val) { - byteVal = val; - } + void __set_byteVal(const TByteColumn& val); - void __set_i16Val(const TI16Column& val) { - i16Val = val; - } + void __set_i16Val(const TI16Column& val); - void __set_i32Val(const TI32Column& val) { - i32Val = val; - } + void __set_i32Val(const TI32Column& val); - void __set_i64Val(const TI64Column& val) { - i64Val = val; - } + void __set_i64Val(const TI64Column& val); - void __set_doubleVal(const TDoubleColumn& val) { - doubleVal = val; - } + void __set_doubleVal(const TDoubleColumn& val); - void __set_stringVal(const TStringColumn& val) { - stringVal = val; - } + void __set_stringVal(const TStringColumn& val); - void __set_binaryVal(const TBinaryColumn& val) { - binaryVal = val; - } + void __set_binaryVal(const TBinaryColumn& val); bool operator == (const TColumn & rhs) const { @@ -1638,13 +1713,14 @@ class TColumn { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TColumn& obj); }; void swap(TColumn &a, TColumn &b); typedef struct _TRowSet__isset { _TRowSet__isset() : columns(false) {} - bool columns; + bool columns :1; } _TRowSet__isset; class TRowSet { @@ -1653,29 +1729,23 @@ class TRowSet { static const char* ascii_fingerprint; // = "46DA30A870489C7A58105AE0080DAEBF"; static const uint8_t binary_fingerprint[16]; // = {0x46,0xDA,0x30,0xA8,0x70,0x48,0x9C,0x7A,0x58,0x10,0x5A,0xE0,0x08,0x0D,0xAE,0xBF}; + TRowSet(const TRowSet&); + TRowSet& operator=(const TRowSet&); TRowSet() : startRowOffset(0) { } - virtual ~TRowSet() throw() {} - + virtual ~TRowSet() throw(); int64_t startRowOffset; std::vector<TRow> rows; std::vector<TColumn> columns; _TRowSet__isset __isset; - void __set_startRowOffset(const int64_t val) { - startRowOffset = val; - } + void __set_startRowOffset(const int64_t val); - void __set_rows(const std::vector<TRow> & val) { - rows = val; - } + void __set_rows(const std::vector<TRow> & val); - void __set_columns(const std::vector<TColumn> & val) { - columns = val; - __isset.columns = true; - } + void __set_columns(const std::vector<TColumn> & val); bool operator == (const TRowSet & rhs) const { @@ -1698,16 +1768,17 @@ class TRowSet { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TRowSet& obj); }; void swap(TRowSet &a, TRowSet &b); typedef struct _TStatus__isset { _TStatus__isset() : infoMessages(false), sqlState(false), errorCode(false), errorMessage(false) {} - bool infoMessages; - bool sqlState; - bool errorCode; - bool errorMessage; + bool infoMessages :1; + bool sqlState :1; + bool errorCode :1; + bool errorMessage :1; } _TStatus__isset; class TStatus { @@ -1716,11 +1787,12 @@ class TStatus { static const char* ascii_fingerprint; // = "D5DEF49634A59C615C1B3A6F7D0DADB5"; static const uint8_t binary_fingerprint[16]; // = {0xD5,0xDE,0xF4,0x96,0x34,0xA5,0x9C,0x61,0x5C,0x1B,0x3A,0x6F,0x7D,0x0D,0xAD,0xB5}; + TStatus(const TStatus&); + TStatus& operator=(const TStatus&); TStatus() : statusCode((TStatusCode::type)0), sqlState(), errorCode(0), errorMessage() { } - virtual ~TStatus() throw() {} - + virtual ~TStatus() throw(); TStatusCode::type statusCode; std::vector<std::string> infoMessages; std::string sqlState; @@ -1729,29 +1801,15 @@ class TStatus { _TStatus__isset __isset; - void __set_statusCode(const TStatusCode::type val) { - statusCode = val; - } + void __set_statusCode(const TStatusCode::type val); - void __set_infoMessages(const std::vector<std::string> & val) { - infoMessages = val; - __isset.infoMessages = true; - } + void __set_infoMessages(const std::vector<std::string> & val); - void __set_sqlState(const std::string& val) { - sqlState = val; - __isset.sqlState = true; - } + void __set_sqlState(const std::string& val); - void __set_errorCode(const int32_t val) { - errorCode = val; - __isset.errorCode = true; - } + void __set_errorCode(const int32_t val); - void __set_errorMessage(const std::string& val) { - errorMessage = val; - __isset.errorMessage = true; - } + void __set_errorMessage(const std::string& val); bool operator == (const TStatus & rhs) const { @@ -1784,6 +1842,7 @@ class TStatus { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TStatus& obj); }; void swap(TStatus &a, TStatus &b); @@ -1795,21 +1854,18 @@ class THandleIdentifier { static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972"; static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72}; + THandleIdentifier(const THandleIdentifier&); + THandleIdentifier& operator=(const THandleIdentifier&); THandleIdentifier() : guid(), secret() { } - virtual ~THandleIdentifier() throw() {} - + virtual ~THandleIdentifier() throw(); std::string guid; std::string secret; - void __set_guid(const std::string& val) { - guid = val; - } + void __set_guid(const std::string& val); - void __set_secret(const std::string& val) { - secret = val; - } + void __set_secret(const std::string& val); bool operator == (const THandleIdentifier & rhs) const { @@ -1828,6 +1884,7 @@ class THandleIdentifier { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const THandleIdentifier& obj); }; void swap(THandleIdentifier &a, THandleIdentifier &b); @@ -1839,16 +1896,15 @@ class TSessionHandle { static const char* ascii_fingerprint; // = "A756D3DBE614FB13F70BF7F7B6EB3D73"; static const uint8_t binary_fingerprint[16]; // = {0xA7,0x56,0xD3,0xDB,0xE6,0x14,0xFB,0x13,0xF7,0x0B,0xF7,0xF7,0xB6,0xEB,0x3D,0x73}; + TSessionHandle(const TSessionHandle&); + TSessionHandle& operator=(const TSessionHandle&); TSessionHandle() { } - virtual ~TSessionHandle() throw() {} - + virtual ~TSessionHandle() throw(); THandleIdentifier sessionId; - void __set_sessionId(const THandleIdentifier& val) { - sessionId = val; - } + void __set_sessionId(const THandleIdentifier& val); bool operator == (const TSessionHandle & rhs) const { @@ -1865,13 +1921,14 @@ class TSessionHandle { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TSessionHandle& obj); }; void swap(TSessionHandle &a, TSessionHandle &b); typedef struct _TOperationHandle__isset { _TOperationHandle__isset() : modifiedRowCount(false) {} - bool modifiedRowCount; + bool modifiedRowCount :1; } _TOperationHandle__isset; class TOperationHandle { @@ -1880,11 +1937,12 @@ class TOperationHandle { static const char* ascii_fingerprint; // = "29FD80F4F96804A30FCC59C23D2E5349"; static const uint8_t binary_fingerprint[16]; // = {0x29,0xFD,0x80,0xF4,0xF9,0x68,0x04,0xA3,0x0F,0xCC,0x59,0xC2,0x3D,0x2E,0x53,0x49}; + TOperationHandle(const TOperationHandle&); + TOperationHandle& operator=(const TOperationHandle&); TOperationHandle() : operationType((TOperationType::type)0), hasResultSet(0), modifiedRowCount(0) { } - virtual ~TOperationHandle() throw() {} - + virtual ~TOperationHandle() throw(); THandleIdentifier operationId; TOperationType::type operationType; bool hasResultSet; @@ -1892,22 +1950,13 @@ class TOperationHandle { _TOperationHandle__isset __isset; - void __set_operationId(const THandleIdentifier& val) { - operationId = val; - } + void __set_operationId(const THandleIdentifier& val); - void __set_operationType(const TOperationType::type val) { - operationType = val; - } + void __set_operationType(const TOperationType::type val); - void __set_hasResultSet(const bool val) { - hasResultSet = val; - } + void __set_hasResultSet(const bool val); - void __set_modifiedRowCount(const double val) { - modifiedRowCount = val; - __isset.modifiedRowCount = true; - } + void __set_modifiedRowCount(const double val); bool operator == (const TOperationHandle & rhs) const { @@ -1932,15 +1981,16 @@ class TOperationHandle { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TOperationHandle& obj); }; void swap(TOperationHandle &a, TOperationHandle &b); typedef struct _TOpenSessionReq__isset { _TOpenSessionReq__isset() : username(false), password(false), configuration(false) {} - bool username; - bool password; - bool configuration; + bool username :1; + bool password :1; + bool configuration :1; } _TOpenSessionReq__isset; class TOpenSessionReq { @@ -1949,13 +1999,14 @@ class TOpenSessionReq { static const char* ascii_fingerprint; // = "C8FD0F306A16C16BDA7B57F58BFAE5B2"; static const uint8_t binary_fingerprint[16]; // = {0xC8,0xFD,0x0F,0x30,0x6A,0x16,0xC1,0x6B,0xDA,0x7B,0x57,0xF5,0x8B,0xFA,0xE5,0xB2}; + TOpenSessionReq(const TOpenSessionReq&); + TOpenSessionReq& operator=(const TOpenSessionReq&); TOpenSessionReq() : client_protocol((TProtocolVersion::type)7), username(), password() { client_protocol = (TProtocolVersion::type)7; } - virtual ~TOpenSessionReq() throw() {} - + virtual ~TOpenSessionReq() throw(); TProtocolVersion::type client_protocol; std::string username; std::string password; @@ -1963,24 +2014,13 @@ class TOpenSessionReq { _TOpenSessionReq__isset __isset; - void __set_client_protocol(const TProtocolVersion::type val) { - client_protocol = val; - } + void __set_client_protocol(const TProtocolVersion::type val); - void __set_username(const std::string& val) { - username = val; - __isset.username = true; - } + void __set_username(const std::string& val); - void __set_password(const std::string& val) { - password = val; - __isset.password = true; - } + void __set_password(const std::string& val); - void __set_configuration(const std::map<std::string, std::string> & val) { - configuration = val; - __isset.configuration = true; - } + void __set_configuration(const std::map<std::string, std::string> & val); bool operator == (const TOpenSessionReq & rhs) const { @@ -2009,14 +2049,15 @@ class TOpenSessionReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TOpenSessionReq& obj); }; void swap(TOpenSessionReq &a, TOpenSessionReq &b); typedef struct _TOpenSessionResp__isset { _TOpenSessionResp__isset() : sessionHandle(false), configuration(false) {} - bool sessionHandle; - bool configuration; + bool sessionHandle :1; + bool configuration :1; } _TOpenSessionResp__isset; class TOpenSessionResp { @@ -2025,13 +2066,14 @@ class TOpenSessionResp { static const char* ascii_fingerprint; // = "CFE7D7F4E9EC671F2518ED74FEE9F163"; static const uint8_t binary_fingerprint[16]; // = {0xCF,0xE7,0xD7,0xF4,0xE9,0xEC,0x67,0x1F,0x25,0x18,0xED,0x74,0xFE,0xE9,0xF1,0x63}; + TOpenSessionResp(const TOpenSessionResp&); + TOpenSessionResp& operator=(const TOpenSessionResp&); TOpenSessionResp() : serverProtocolVersion((TProtocolVersion::type)7) { serverProtocolVersion = (TProtocolVersion::type)7; } - virtual ~TOpenSessionResp() throw() {} - + virtual ~TOpenSessionResp() throw(); TStatus status; TProtocolVersion::type serverProtocolVersion; TSessionHandle sessionHandle; @@ -2039,23 +2081,13 @@ class TOpenSessionResp { _TOpenSessionResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_serverProtocolVersion(const TProtocolVersion::type val) { - serverProtocolVersion = val; - } + void __set_serverProtocolVersion(const TProtocolVersion::type val); - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - __isset.sessionHandle = true; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_configuration(const std::map<std::string, std::string> & val) { - configuration = val; - __isset.configuration = true; - } + void __set_configuration(const std::map<std::string, std::string> & val); bool operator == (const TOpenSessionResp & rhs) const { @@ -2082,6 +2114,7 @@ class TOpenSessionResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TOpenSessionResp& obj); }; void swap(TOpenSessionResp &a, TOpenSessionResp &b); @@ -2093,16 +2126,15 @@ class TCloseSessionReq { static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF"; static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF}; + TCloseSessionReq(const TCloseSessionReq&); + TCloseSessionReq& operator=(const TCloseSessionReq&); TCloseSessionReq() { } - virtual ~TCloseSessionReq() throw() {} - + virtual ~TCloseSessionReq() throw(); TSessionHandle sessionHandle; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); bool operator == (const TCloseSessionReq & rhs) const { @@ -2119,6 +2151,7 @@ class TCloseSessionReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TCloseSessionReq& obj); }; void swap(TCloseSessionReq &a, TCloseSessionReq &b); @@ -2130,16 +2163,15 @@ class TCloseSessionResp { static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2"; static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2}; + TCloseSessionResp(const TCloseSessionResp&); + TCloseSessionResp& operator=(const TCloseSessionResp&); TCloseSessionResp() { } - virtual ~TCloseSessionResp() throw() {} - + virtual ~TCloseSessionResp() throw(); TStatus status; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); bool operator == (const TCloseSessionResp & rhs) const { @@ -2156,18 +2188,19 @@ class TCloseSessionResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TCloseSessionResp& obj); }; void swap(TCloseSessionResp &a, TCloseSessionResp &b); typedef struct _TGetInfoValue__isset { _TGetInfoValue__isset() : stringValue(false), smallIntValue(false), integerBitmask(false), integerFlag(false), binaryValue(false), lenValue(false) {} - bool stringValue; - bool smallIntValue; - bool integerBitmask; - bool integerFlag; - bool binaryValue; - bool lenValue; + bool stringValue :1; + bool smallIntValue :1; + bool integerBitmask :1; + bool integerFlag :1; + bool binaryValue :1; + bool lenValue :1; } _TGetInfoValue__isset; class TGetInfoValue { @@ -2176,11 +2209,12 @@ class TGetInfoValue { static const char* ascii_fingerprint; // = "057FED11279FD7248CFE73EE82ED579E"; static const uint8_t binary_fingerprint[16]; // = {0x05,0x7F,0xED,0x11,0x27,0x9F,0xD7,0x24,0x8C,0xFE,0x73,0xEE,0x82,0xED,0x57,0x9E}; + TGetInfoValue(const TGetInfoValue&); + TGetInfoValue& operator=(const TGetInfoValue&); TGetInfoValue() : stringValue(), smallIntValue(0), integerBitmask(0), integerFlag(0), binaryValue(0), lenValue(0) { } - virtual ~TGetInfoValue() throw() {} - + virtual ~TGetInfoValue() throw(); std::string stringValue; int16_t smallIntValue; int32_t integerBitmask; @@ -2190,29 +2224,17 @@ class TGetInfoValue { _TGetInfoValue__isset __isset; - void __set_stringValue(const std::string& val) { - stringValue = val; - } + void __set_stringValue(const std::string& val); - void __set_smallIntValue(const int16_t val) { - smallIntValue = val; - } + void __set_smallIntValue(const int16_t val); - void __set_integerBitmask(const int32_t val) { - integerBitmask = val; - } + void __set_integerBitmask(const int32_t val); - void __set_integerFlag(const int32_t val) { - integerFlag = val; - } + void __set_integerFlag(const int32_t val); - void __set_binaryValue(const int32_t val) { - binaryValue = val; - } + void __set_binaryValue(const int32_t val); - void __set_lenValue(const int64_t val) { - lenValue = val; - } + void __set_lenValue(const int64_t val); bool operator == (const TGetInfoValue & rhs) const { @@ -2239,6 +2261,7 @@ class TGetInfoValue { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetInfoValue& obj); }; void swap(TGetInfoValue &a, TGetInfoValue &b); @@ -2250,21 +2273,18 @@ class TGetInfoReq { static const char* ascii_fingerprint; // = "95675B1A0BADE5F7EDE323809DB679B2"; static const uint8_t binary_fingerprint[16]; // = {0x95,0x67,0x5B,0x1A,0x0B,0xAD,0xE5,0xF7,0xED,0xE3,0x23,0x80,0x9D,0xB6,0x79,0xB2}; + TGetInfoReq(const TGetInfoReq&); + TGetInfoReq& operator=(const TGetInfoReq&); TGetInfoReq() : infoType((TGetInfoType::type)0) { } - virtual ~TGetInfoReq() throw() {} - + virtual ~TGetInfoReq() throw(); TSessionHandle sessionHandle; TGetInfoType::type infoType; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_infoType(const TGetInfoType::type val) { - infoType = val; - } + void __set_infoType(const TGetInfoType::type val); bool operator == (const TGetInfoReq & rhs) const { @@ -2283,6 +2303,7 @@ class TGetInfoReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetInfoReq& obj); }; void swap(TGetInfoReq &a, TGetInfoReq &b); @@ -2294,21 +2315,18 @@ class TGetInfoResp { static const char* ascii_fingerprint; // = "72AFA10A82728B51FDE91092012868DE"; static const uint8_t binary_fingerprint[16]; // = {0x72,0xAF,0xA1,0x0A,0x82,0x72,0x8B,0x51,0xFD,0xE9,0x10,0x92,0x01,0x28,0x68,0xDE}; + TGetInfoResp(const TGetInfoResp&); + TGetInfoResp& operator=(const TGetInfoResp&); TGetInfoResp() { } - virtual ~TGetInfoResp() throw() {} - + virtual ~TGetInfoResp() throw(); TStatus status; TGetInfoValue infoValue; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_infoValue(const TGetInfoValue& val) { - infoValue = val; - } + void __set_infoValue(const TGetInfoValue& val); bool operator == (const TGetInfoResp & rhs) const { @@ -2327,14 +2345,15 @@ class TGetInfoResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetInfoResp& obj); }; void swap(TGetInfoResp &a, TGetInfoResp &b); typedef struct _TExecuteStatementReq__isset { _TExecuteStatementReq__isset() : confOverlay(false), runAsync(true) {} - bool confOverlay; - bool runAsync; + bool confOverlay :1; + bool runAsync :1; } _TExecuteStatementReq__isset; class TExecuteStatementReq { @@ -2343,11 +2362,12 @@ class TExecuteStatementReq { static const char* ascii_fingerprint; // = "FED75DB77E66D76EC1939A51FB0D96FA"; static const uint8_t binary_fingerprint[16]; // = {0xFE,0xD7,0x5D,0xB7,0x7E,0x66,0xD7,0x6E,0xC1,0x93,0x9A,0x51,0xFB,0x0D,0x96,0xFA}; + TExecuteStatementReq(const TExecuteStatementReq&); + TExecuteStatementReq& operator=(const TExecuteStatementReq&); TExecuteStatementReq() : statement(), runAsync(false) { } - virtual ~TExecuteStatementReq() throw() {} - + virtual ~TExecuteStatementReq() throw(); TSessionHandle sessionHandle; std::string statement; std::map<std::string, std::string> confOverlay; @@ -2355,23 +2375,13 @@ class TExecuteStatementReq { _TExecuteStatementReq__isset __isset; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_statement(const std::string& val) { - statement = val; - } + void __set_statement(const std::string& val); - void __set_confOverlay(const std::map<std::string, std::string> & val) { - confOverlay = val; - __isset.confOverlay = true; - } + void __set_confOverlay(const std::map<std::string, std::string> & val); - void __set_runAsync(const bool val) { - runAsync = val; - __isset.runAsync = true; - } + void __set_runAsync(const bool val); bool operator == (const TExecuteStatementReq & rhs) const { @@ -2398,13 +2408,14 @@ class TExecuteStatementReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TExecuteStatementReq& obj); }; void swap(TExecuteStatementReq &a, TExecuteStatementReq &b); typedef struct _TExecuteStatementResp__isset { _TExecuteStatementResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TExecuteStatementResp__isset; class TExecuteStatementResp { @@ -2413,24 +2424,20 @@ class TExecuteStatementResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TExecuteStatementResp(const TExecuteStatementResp&); + TExecuteStatementResp& operator=(const TExecuteStatementResp&); TExecuteStatementResp() { } - virtual ~TExecuteStatementResp() throw() {} - + virtual ~TExecuteStatementResp() throw(); TStatus status; TOperationHandle operationHandle; _TExecuteStatementResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TExecuteStatementResp & rhs) const { @@ -2451,6 +2458,7 @@ class TExecuteStatementResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TExecuteStatementResp& obj); }; void swap(TExecuteStatementResp &a, TExecuteStatementResp &b); @@ -2462,16 +2470,15 @@ class TGetTypeInfoReq { static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF"; static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF}; + TGetTypeInfoReq(const TGetTypeInfoReq&); + TGetTypeInfoReq& operator=(const TGetTypeInfoReq&); TGetTypeInfoReq() { } - virtual ~TGetTypeInfoReq() throw() {} - + virtual ~TGetTypeInfoReq() throw(); TSessionHandle sessionHandle; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); bool operator == (const TGetTypeInfoReq & rhs) const { @@ -2488,13 +2495,14 @@ class TGetTypeInfoReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetTypeInfoReq& obj); }; void swap(TGetTypeInfoReq &a, TGetTypeInfoReq &b); typedef struct _TGetTypeInfoResp__isset { _TGetTypeInfoResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetTypeInfoResp__isset; class TGetTypeInfoResp { @@ -2503,24 +2511,20 @@ class TGetTypeInfoResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetTypeInfoResp(const TGetTypeInfoResp&); + TGetTypeInfoResp& operator=(const TGetTypeInfoResp&); TGetTypeInfoResp() { } - virtual ~TGetTypeInfoResp() throw() {} - + virtual ~TGetTypeInfoResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetTypeInfoResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetTypeInfoResp & rhs) const { @@ -2541,6 +2545,7 @@ class TGetTypeInfoResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetTypeInfoResp& obj); }; void swap(TGetTypeInfoResp &a, TGetTypeInfoResp &b); @@ -2552,16 +2557,15 @@ class TGetCatalogsReq { static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF"; static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF}; + TGetCatalogsReq(const TGetCatalogsReq&); + TGetCatalogsReq& operator=(const TGetCatalogsReq&); TGetCatalogsReq() { } - virtual ~TGetCatalogsReq() throw() {} - + virtual ~TGetCatalogsReq() throw(); TSessionHandle sessionHandle; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); bool operator == (const TGetCatalogsReq & rhs) const { @@ -2578,13 +2582,14 @@ class TGetCatalogsReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetCatalogsReq& obj); }; void swap(TGetCatalogsReq &a, TGetCatalogsReq &b); typedef struct _TGetCatalogsResp__isset { _TGetCatalogsResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetCatalogsResp__isset; class TGetCatalogsResp { @@ -2593,24 +2598,20 @@ class TGetCatalogsResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetCatalogsResp(const TGetCatalogsResp&); + TGetCatalogsResp& operator=(const TGetCatalogsResp&); TGetCatalogsResp() { } - virtual ~TGetCatalogsResp() throw() {} - + virtual ~TGetCatalogsResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetCatalogsResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetCatalogsResp & rhs) const { @@ -2631,14 +2632,15 @@ class TGetCatalogsResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetCatalogsResp& obj); }; void swap(TGetCatalogsResp &a, TGetCatalogsResp &b); typedef struct _TGetSchemasReq__isset { _TGetSchemasReq__isset() : catalogName(false), schemaName(false) {} - bool catalogName; - bool schemaName; + bool catalogName :1; + bool schemaName :1; } _TGetSchemasReq__isset; class TGetSchemasReq { @@ -2647,30 +2649,23 @@ class TGetSchemasReq { static const char* ascii_fingerprint; // = "28A9D12DE8393DD3E73FC1E5AE6E113B"; static const uint8_t binary_fingerprint[16]; // = {0x28,0xA9,0xD1,0x2D,0xE8,0x39,0x3D,0xD3,0xE7,0x3F,0xC1,0xE5,0xAE,0x6E,0x11,0x3B}; + TGetSchemasReq(const TGetSchemasReq&); + TGetSchemasReq& operator=(const TGetSchemasReq&); TGetSchemasReq() : catalogName(), schemaName() { } - virtual ~TGetSchemasReq() throw() {} - + virtual ~TGetSchemasReq() throw(); TSessionHandle sessionHandle; TIdentifier catalogName; TPatternOrIdentifier schemaName; _TGetSchemasReq__isset __isset; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_catalogName(const TIdentifier& val) { - catalogName = val; - __isset.catalogName = true; - } + void __set_catalogName(const TIdentifier& val); - void __set_schemaName(const TPatternOrIdentifier& val) { - schemaName = val; - __isset.schemaName = true; - } + void __set_schemaName(const TPatternOrIdentifier& val); bool operator == (const TGetSchemasReq & rhs) const { @@ -2695,13 +2690,14 @@ class TGetSchemasReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetSchemasReq& obj); }; void swap(TGetSchemasReq &a, TGetSchemasReq &b); typedef struct _TGetSchemasResp__isset { _TGetSchemasResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetSchemasResp__isset; class TGetSchemasResp { @@ -2710,24 +2706,20 @@ class TGetSchemasResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetSchemasResp(const TGetSchemasResp&); + TGetSchemasResp& operator=(const TGetSchemasResp&); TGetSchemasResp() { } - virtual ~TGetSchemasResp() throw() {} - + virtual ~TGetSchemasResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetSchemasResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetSchemasResp & rhs) const { @@ -2748,16 +2740,17 @@ class TGetSchemasResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetSchemasResp& obj); }; void swap(TGetSchemasResp &a, TGetSchemasResp &b); typedef struct _TGetTablesReq__isset { _TGetTablesReq__isset() : catalogName(false), schemaName(false), tableName(false), tableTypes(false) {} - bool catalogName; - bool schemaName; - bool tableName; - bool tableTypes; + bool catalogName :1; + bool schemaName :1; + bool tableName :1; + bool tableTypes :1; } _TGetTablesReq__isset; class TGetTablesReq { @@ -2766,11 +2759,12 @@ class TGetTablesReq { static const char* ascii_fingerprint; // = "C80DFEE06850052F5A445BE81ED763DB"; static const uint8_t binary_fingerprint[16]; // = {0xC8,0x0D,0xFE,0xE0,0x68,0x50,0x05,0x2F,0x5A,0x44,0x5B,0xE8,0x1E,0xD7,0x63,0xDB}; + TGetTablesReq(const TGetTablesReq&); + TGetTablesReq& operator=(const TGetTablesReq&); TGetTablesReq() : catalogName(), schemaName(), tableName() { } - virtual ~TGetTablesReq() throw() {} - + virtual ~TGetTablesReq() throw(); TSessionHandle sessionHandle; TPatternOrIdentifier catalogName; TPatternOrIdentifier schemaName; @@ -2779,29 +2773,15 @@ class TGetTablesReq { _TGetTablesReq__isset __isset; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_catalogName(const TPatternOrIdentifier& val) { - catalogName = val; - __isset.catalogName = true; - } + void __set_catalogName(const TPatternOrIdentifier& val); - void __set_schemaName(const TPatternOrIdentifier& val) { - schemaName = val; - __isset.schemaName = true; - } + void __set_schemaName(const TPatternOrIdentifier& val); - void __set_tableName(const TPatternOrIdentifier& val) { - tableName = val; - __isset.tableName = true; - } + void __set_tableName(const TPatternOrIdentifier& val); - void __set_tableTypes(const std::vector<std::string> & val) { - tableTypes = val; - __isset.tableTypes = true; - } + void __set_tableTypes(const std::vector<std::string> & val); bool operator == (const TGetTablesReq & rhs) const { @@ -2834,13 +2814,14 @@ class TGetTablesReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetTablesReq& obj); }; void swap(TGetTablesReq &a, TGetTablesReq &b); typedef struct _TGetTablesResp__isset { _TGetTablesResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetTablesResp__isset; class TGetTablesResp { @@ -2849,24 +2830,20 @@ class TGetTablesResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetTablesResp(const TGetTablesResp&); + TGetTablesResp& operator=(const TGetTablesResp&); TGetTablesResp() { } - virtual ~TGetTablesResp() throw() {} - + virtual ~TGetTablesResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetTablesResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetTablesResp & rhs) const { @@ -2887,6 +2864,7 @@ class TGetTablesResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetTablesResp& obj); }; void swap(TGetTablesResp &a, TGetTablesResp &b); @@ -2898,16 +2876,15 @@ class TGetTableTypesReq { static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF"; static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF}; + TGetTableTypesReq(const TGetTableTypesReq&); + TGetTableTypesReq& operator=(const TGetTableTypesReq&); TGetTableTypesReq() { } - virtual ~TGetTableTypesReq() throw() {} - + virtual ~TGetTableTypesReq() throw(); TSessionHandle sessionHandle; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); bool operator == (const TGetTableTypesReq & rhs) const { @@ -2924,13 +2901,14 @@ class TGetTableTypesReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetTableTypesReq& obj); }; void swap(TGetTableTypesReq &a, TGetTableTypesReq &b); typedef struct _TGetTableTypesResp__isset { _TGetTableTypesResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetTableTypesResp__isset; class TGetTableTypesResp { @@ -2939,24 +2917,20 @@ class TGetTableTypesResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetTableTypesResp(const TGetTableTypesResp&); + TGetTableTypesResp& operator=(const TGetTableTypesResp&); TGetTableTypesResp() { } - virtual ~TGetTableTypesResp() throw() {} - + virtual ~TGetTableTypesResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetTableTypesResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetTableTypesResp & rhs) const { @@ -2977,16 +2951,17 @@ class TGetTableTypesResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetTableTypesResp& obj); }; void swap(TGetTableTypesResp &a, TGetTableTypesResp &b); typedef struct _TGetColumnsReq__isset { _TGetColumnsReq__isset() : catalogName(false), schemaName(false), tableName(false), columnName(false) {} - bool catalogName; - bool schemaName; - bool tableName; - bool columnName; + bool catalogName :1; + bool schemaName :1; + bool tableName :1; + bool columnName :1; } _TGetColumnsReq__isset; class TGetColumnsReq { @@ -2995,11 +2970,12 @@ class TGetColumnsReq { static const char* ascii_fingerprint; // = "72D0F28ED33A49B7306DF63EEE956C28"; static const uint8_t binary_fingerprint[16]; // = {0x72,0xD0,0xF2,0x8E,0xD3,0x3A,0x49,0xB7,0x30,0x6D,0xF6,0x3E,0xEE,0x95,0x6C,0x28}; + TGetColumnsReq(const TGetColumnsReq&); + TGetColumnsReq& operator=(const TGetColumnsReq&); TGetColumnsReq() : catalogName(), schemaName(), tableName(), columnName() { } - virtual ~TGetColumnsReq() throw() {} - + virtual ~TGetColumnsReq() throw(); TSessionHandle sessionHandle; TIdentifier catalogName; TPatternOrIdentifier schemaName; @@ -3008,29 +2984,15 @@ class TGetColumnsReq { _TGetColumnsReq__isset __isset; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_catalogName(const TIdentifier& val) { - catalogName = val; - __isset.catalogName = true; - } + void __set_catalogName(const TIdentifier& val); - void __set_schemaName(const TPatternOrIdentifier& val) { - schemaName = val; - __isset.schemaName = true; - } + void __set_schemaName(const TPatternOrIdentifier& val); - void __set_tableName(const TPatternOrIdentifier& val) { - tableName = val; - __isset.tableName = true; - } + void __set_tableName(const TPatternOrIdentifier& val); - void __set_columnName(const TPatternOrIdentifier& val) { - columnName = val; - __isset.columnName = true; - } + void __set_columnName(const TPatternOrIdentifier& val); bool operator == (const TGetColumnsReq & rhs) const { @@ -3063,13 +3025,14 @@ class TGetColumnsReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetColumnsReq& obj); }; void swap(TGetColumnsReq &a, TGetColumnsReq &b); typedef struct _TGetColumnsResp__isset { _TGetColumnsResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetColumnsResp__isset; class TGetColumnsResp { @@ -3078,24 +3041,20 @@ class TGetColumnsResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetColumnsResp(const TGetColumnsResp&); + TGetColumnsResp& operator=(const TGetColumnsResp&); TGetColumnsResp() { } - virtual ~TGetColumnsResp() throw() {} - + virtual ~TGetColumnsResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetColumnsResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetColumnsResp & rhs) const { @@ -3116,14 +3075,15 @@ class TGetColumnsResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetColumnsResp& obj); }; void swap(TGetColumnsResp &a, TGetColumnsResp &b); typedef struct _TGetFunctionsReq__isset { _TGetFunctionsReq__isset() : catalogName(false), schemaName(false) {} - bool catalogName; - bool schemaName; + bool catalogName :1; + bool schemaName :1; } _TGetFunctionsReq__isset; class TGetFunctionsReq { @@ -3132,11 +3092,12 @@ class TGetFunctionsReq { static const char* ascii_fingerprint; // = "0887E0916ADE4521BF6017B534493138"; static const uint8_t binary_fingerprint[16]; // = {0x08,0x87,0xE0,0x91,0x6A,0xDE,0x45,0x21,0xBF,0x60,0x17,0xB5,0x34,0x49,0x31,0x38}; + TGetFunctionsReq(const TGetFunctionsReq&); + TGetFunctionsReq& operator=(const TGetFunctionsReq&); TGetFunctionsReq() : catalogName(), schemaName(), functionName() { } - virtual ~TGetFunctionsReq() throw() {} - + virtual ~TGetFunctionsReq() throw(); TSessionHandle sessionHandle; TIdentifier catalogName; TPatternOrIdentifier schemaName; @@ -3144,23 +3105,13 @@ class TGetFunctionsReq { _TGetFunctionsReq__isset __isset; - void __set_sessionHandle(const TSessionHandle& val) { - sessionHandle = val; - } + void __set_sessionHandle(const TSessionHandle& val); - void __set_catalogName(const TIdentifier& val) { - catalogName = val; - __isset.catalogName = true; - } + void __set_catalogName(const TIdentifier& val); - void __set_schemaName(const TPatternOrIdentifier& val) { - schemaName = val; - __isset.schemaName = true; - } + void __set_schemaName(const TPatternOrIdentifier& val); - void __set_functionName(const TPatternOrIdentifier& val) { - functionName = val; - } + void __set_functionName(const TPatternOrIdentifier& val); bool operator == (const TGetFunctionsReq & rhs) const { @@ -3187,13 +3138,14 @@ class TGetFunctionsReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetFunctionsReq& obj); }; void swap(TGetFunctionsReq &a, TGetFunctionsReq &b); typedef struct _TGetFunctionsResp__isset { _TGetFunctionsResp__isset() : operationHandle(false) {} - bool operationHandle; + bool operationHandle :1; } _TGetFunctionsResp__isset; class TGetFunctionsResp { @@ -3202,24 +3154,20 @@ class TGetFunctionsResp { static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286"; static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86}; + TGetFunctionsResp(const TGetFunctionsResp&); + TGetFunctionsResp& operator=(const TGetFunctionsResp&); TGetFunctionsResp() { } - virtual ~TGetFunctionsResp() throw() {} - + virtual ~TGetFunctionsResp() throw(); TStatus status; TOperationHandle operationHandle; _TGetFunctionsResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - __isset.operationHandle = true; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetFunctionsResp & rhs) const { @@ -3240,6 +3188,7 @@ class TGetFunctionsResp { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetFunctionsResp& obj); }; void swap(TGetFunctionsResp &a, TGetFunctionsResp &b); @@ -3251,16 +3200,15 @@ class TGetOperationStatusReq { static const char* ascii_fingerprint; // = "414FA38522AE6B9CEC1438B56CA1DE5A"; static const uint8_t binary_fingerprint[16]; // = {0x41,0x4F,0xA3,0x85,0x22,0xAE,0x6B,0x9C,0xEC,0x14,0x38,0xB5,0x6C,0xA1,0xDE,0x5A}; + TGetOperationStatusReq(const TGetOperationStatusReq&); + TGetOperationStatusReq& operator=(const TGetOperationStatusReq&); TGetOperationStatusReq() { } - virtual ~TGetOperationStatusReq() throw() {} - + virtual ~TGetOperationStatusReq() throw(); TOperationHandle operationHandle; - void __set_operationHandle(const TOperationHandle& val) { - operationHandle = val; - } + void __set_operationHandle(const TOperationHandle& val); bool operator == (const TGetOperationStatusReq & rhs) const { @@ -3277,16 +3225,17 @@ class TGetOperationStatusReq { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + friend std::ostream& operator<<(std::ostream& out, const TGetOperationStatusReq& obj); }; void swap(TGetOperationStatusReq &a, TGetOperationStatusReq &b); typedef struct _TGetOperationStatusResp__isset { _TGetOperationStatusResp__isset() : operationState(false), sqlState(false), errorCode(false), errorMessage(false) {} - bool operationState; - bool sqlState; - bool errorCode; - bool errorMessage; + bool operationState :1; + bool sqlState :1; + bool errorCode :1; + bool errorMessage :1; } _TGetOperationStatusResp__isset; class TGetOperationStatusResp { @@ -3295,11 +3244,12 @@ class TGetOperationStatusResp { static const char* ascii_fingerprint; // = "BD124DB87A5A2E7D11945BD1B17F013D"; static const uint8_t binary_fingerprint[16]; // = {0xBD,0x12,0x4D,0xB8,0x7A,0x5A,0x2E,0x7D,0x11,0x94,0x5B,0xD1,0xB1,0x7F,0x01,0x3D}; + TGetOperationStatusResp(const TGetOperationStatusResp&); + TGetOperationStatusResp& operator=(const TGetOperationStatusResp&); TGetOperationStatusResp() : operationState((TOperationState::type)0), sqlState(), errorCode(0), errorMessage() { } - virtual ~TGetOperationStatusResp() throw() {} - + virtual ~TGetOperationStatusResp() throw(); TStatus status; TOperationState::type operationState; std::string sqlState; @@ -3308,29 +3258,15 @@ class TGetOperationStatusResp { _TGetOperationStatusResp__isset __isset; - void __set_status(const TStatus& val) { - status = val; - } + void __set_status(const TStatus& val); - void __set_operationState(const TOperationState::type val) { - operationState = val; - __isset.operationState = true; - } + void __set_operationState(const TOperationState::type val); - void __set_sqlState(const std::string& val) { - sqlState = val; - __isset.sqlState = true; - } + void __set_sqlState(const std::string& val); - void __set_errorCode(const int32_t val) { - errorCode = val; - __isset.errorCode = true; - } + voi
<TRUNCATED>
