You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by su...@apache.org on 2015/07/17 21:53:04 UTC
[12/48] hive git commit: HIVE-9152 - Dynamic Partition Pruning [Spark
Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)
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>