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:05 UTC
[13/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.cpp
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp b/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
index 86eeea3..742cfdc 100644
--- a/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
+++ b/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -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,6 +7,9 @@
#include "TCLIService_types.h"
#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
namespace apache { namespace hive { namespace service { namespace cli { namespace thrift {
@@ -262,6 +265,21 @@ const char* _kTFetchOrientationNames[] = {
};
const std::map<int, const char*> _TFetchOrientation_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kTFetchOrientationValues, _kTFetchOrientationNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+TTypeQualifierValue::~TTypeQualifierValue() throw() {
+}
+
+
+void TTypeQualifierValue::__set_i32Value(const int32_t val) {
+ this->i32Value = val;
+__isset.i32Value = true;
+}
+
+void TTypeQualifierValue::__set_stringValue(const std::string& val) {
+ this->stringValue = val;
+__isset.stringValue = true;
+}
+
const char* TTypeQualifierValue::ascii_fingerprint = "A7801670116150C65ACA43E6F679BA79";
const uint8_t TTypeQualifierValue::binary_fingerprint[16] = {0xA7,0x80,0x16,0x70,0x11,0x61,0x50,0xC6,0x5A,0xCA,0x43,0xE6,0xF6,0x79,0xBA,0x79};
@@ -315,6 +333,7 @@ uint32_t TTypeQualifierValue::read(::apache::thrift::protocol::TProtocol* iprot)
uint32_t TTypeQualifierValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TTypeQualifierValue");
if (this->__isset.i32Value) {
@@ -329,6 +348,7 @@ uint32_t TTypeQualifierValue::write(::apache::thrift::protocol::TProtocol* oprot
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -339,6 +359,35 @@ void swap(TTypeQualifierValue &a, TTypeQualifierValue &b) {
swap(a.__isset, b.__isset);
}
+TTypeQualifierValue::TTypeQualifierValue(const TTypeQualifierValue& other0) {
+ i32Value = other0.i32Value;
+ stringValue = other0.stringValue;
+ __isset = other0.__isset;
+}
+TTypeQualifierValue& TTypeQualifierValue::operator=(const TTypeQualifierValue& other1) {
+ i32Value = other1.i32Value;
+ stringValue = other1.stringValue;
+ __isset = other1.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj) {
+ using apache::thrift::to_string;
+ out << "TTypeQualifierValue(";
+ out << "i32Value="; (obj.__isset.i32Value ? (out << to_string(obj.i32Value)) : (out << "<null>"));
+ out << ", " << "stringValue="; (obj.__isset.stringValue ? (out << to_string(obj.stringValue)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TTypeQualifiers::~TTypeQualifiers() throw() {
+}
+
+
+void TTypeQualifiers::__set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val) {
+ this->qualifiers = val;
+}
+
const char* TTypeQualifiers::ascii_fingerprint = "6C72981CFA989214285648FA8C196C47";
const uint8_t TTypeQualifiers::binary_fingerprint[16] = {0x6C,0x72,0x98,0x1C,0xFA,0x98,0x92,0x14,0x28,0x56,0x48,0xFA,0x8C,0x19,0x6C,0x47};
@@ -367,17 +416,17 @@ uint32_t TTypeQualifiers::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->qualifiers.clear();
- uint32_t _size0;
- ::apache::thrift::protocol::TType _ktype1;
- ::apache::thrift::protocol::TType _vtype2;
- xfer += iprot->readMapBegin(_ktype1, _vtype2, _size0);
- uint32_t _i4;
- for (_i4 = 0; _i4 < _size0; ++_i4)
+ uint32_t _size2;
+ ::apache::thrift::protocol::TType _ktype3;
+ ::apache::thrift::protocol::TType _vtype4;
+ xfer += iprot->readMapBegin(_ktype3, _vtype4, _size2);
+ uint32_t _i6;
+ for (_i6 = 0; _i6 < _size2; ++_i6)
{
- std::string _key5;
- xfer += iprot->readString(_key5);
- TTypeQualifierValue& _val6 = this->qualifiers[_key5];
- xfer += _val6.read(iprot);
+ std::string _key7;
+ xfer += iprot->readString(_key7);
+ TTypeQualifierValue& _val8 = this->qualifiers[_key7];
+ xfer += _val8.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -402,16 +451,17 @@ uint32_t TTypeQualifiers::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TTypeQualifiers::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TTypeQualifiers");
xfer += oprot->writeFieldBegin("qualifiers", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->qualifiers.size()));
- std::map<std::string, TTypeQualifierValue> ::const_iterator _iter7;
- for (_iter7 = this->qualifiers.begin(); _iter7 != this->qualifiers.end(); ++_iter7)
+ std::map<std::string, TTypeQualifierValue> ::const_iterator _iter9;
+ for (_iter9 = this->qualifiers.begin(); _iter9 != this->qualifiers.end(); ++_iter9)
{
- xfer += oprot->writeString(_iter7->first);
- xfer += _iter7->second.write(oprot);
+ xfer += oprot->writeString(_iter9->first);
+ xfer += _iter9->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -419,6 +469,7 @@ uint32_t TTypeQualifiers::write(::apache::thrift::protocol::TProtocol* oprot) co
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -427,6 +478,35 @@ void swap(TTypeQualifiers &a, TTypeQualifiers &b) {
swap(a.qualifiers, b.qualifiers);
}
+TTypeQualifiers::TTypeQualifiers(const TTypeQualifiers& other10) {
+ qualifiers = other10.qualifiers;
+}
+TTypeQualifiers& TTypeQualifiers::operator=(const TTypeQualifiers& other11) {
+ qualifiers = other11.qualifiers;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj) {
+ using apache::thrift::to_string;
+ out << "TTypeQualifiers(";
+ out << "qualifiers=" << to_string(obj.qualifiers);
+ out << ")";
+ return out;
+}
+
+
+TPrimitiveTypeEntry::~TPrimitiveTypeEntry() throw() {
+}
+
+
+void TPrimitiveTypeEntry::__set_type(const TTypeId::type val) {
+ this->type = val;
+}
+
+void TPrimitiveTypeEntry::__set_typeQualifiers(const TTypeQualifiers& val) {
+ this->typeQualifiers = val;
+__isset.typeQualifiers = true;
+}
+
const char* TPrimitiveTypeEntry::ascii_fingerprint = "755674F6A5C8EB47868686AE386FBC1C";
const uint8_t TPrimitiveTypeEntry::binary_fingerprint[16] = {0x75,0x56,0x74,0xF6,0xA5,0xC8,0xEB,0x47,0x86,0x86,0x86,0xAE,0x38,0x6F,0xBC,0x1C};
@@ -453,9 +533,9 @@ uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot)
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast8;
- xfer += iprot->readI32(ecast8);
- this->type = (TTypeId::type)ecast8;
+ int32_t ecast12;
+ xfer += iprot->readI32(ecast12);
+ this->type = (TTypeId::type)ecast12;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -485,6 +565,7 @@ uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot)
uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TPrimitiveTypeEntry");
xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
@@ -498,6 +579,7 @@ uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -508,6 +590,35 @@ void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b) {
swap(a.__isset, b.__isset);
}
+TPrimitiveTypeEntry::TPrimitiveTypeEntry(const TPrimitiveTypeEntry& other13) {
+ type = other13.type;
+ typeQualifiers = other13.typeQualifiers;
+ __isset = other13.__isset;
+}
+TPrimitiveTypeEntry& TPrimitiveTypeEntry::operator=(const TPrimitiveTypeEntry& other14) {
+ type = other14.type;
+ typeQualifiers = other14.typeQualifiers;
+ __isset = other14.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TPrimitiveTypeEntry(";
+ out << "type=" << to_string(obj.type);
+ out << ", " << "typeQualifiers="; (obj.__isset.typeQualifiers ? (out << to_string(obj.typeQualifiers)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TArrayTypeEntry::~TArrayTypeEntry() throw() {
+}
+
+
+void TArrayTypeEntry::__set_objectTypePtr(const TTypeEntryPtr val) {
+ this->objectTypePtr = val;
+}
+
const char* TArrayTypeEntry::ascii_fingerprint = "E86CACEB22240450EDCBEFC3A83970E4";
const uint8_t TArrayTypeEntry::binary_fingerprint[16] = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4};
@@ -556,6 +667,7 @@ uint32_t TArrayTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TArrayTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TArrayTypeEntry");
xfer += oprot->writeFieldBegin("objectTypePtr", ::apache::thrift::protocol::T_I32, 1);
@@ -564,6 +676,7 @@ uint32_t TArrayTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) co
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -572,6 +685,34 @@ void swap(TArrayTypeEntry &a, TArrayTypeEntry &b) {
swap(a.objectTypePtr, b.objectTypePtr);
}
+TArrayTypeEntry::TArrayTypeEntry(const TArrayTypeEntry& other15) {
+ objectTypePtr = other15.objectTypePtr;
+}
+TArrayTypeEntry& TArrayTypeEntry::operator=(const TArrayTypeEntry& other16) {
+ objectTypePtr = other16.objectTypePtr;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TArrayTypeEntry(";
+ out << "objectTypePtr=" << to_string(obj.objectTypePtr);
+ out << ")";
+ return out;
+}
+
+
+TMapTypeEntry::~TMapTypeEntry() throw() {
+}
+
+
+void TMapTypeEntry::__set_keyTypePtr(const TTypeEntryPtr val) {
+ this->keyTypePtr = val;
+}
+
+void TMapTypeEntry::__set_valueTypePtr(const TTypeEntryPtr val) {
+ this->valueTypePtr = val;
+}
+
const char* TMapTypeEntry::ascii_fingerprint = "989D1F1AE8D148D5E2119FFEC4BBBEE3";
const uint8_t TMapTypeEntry::binary_fingerprint[16] = {0x98,0x9D,0x1F,0x1A,0xE8,0xD1,0x48,0xD5,0xE2,0x11,0x9F,0xFE,0xC4,0xBB,0xBE,0xE3};
@@ -631,6 +772,7 @@ uint32_t TMapTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TMapTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TMapTypeEntry");
xfer += oprot->writeFieldBegin("keyTypePtr", ::apache::thrift::protocol::T_I32, 1);
@@ -643,6 +785,7 @@ uint32_t TMapTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) cons
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -652,6 +795,33 @@ void swap(TMapTypeEntry &a, TMapTypeEntry &b) {
swap(a.valueTypePtr, b.valueTypePtr);
}
+TMapTypeEntry::TMapTypeEntry(const TMapTypeEntry& other17) {
+ keyTypePtr = other17.keyTypePtr;
+ valueTypePtr = other17.valueTypePtr;
+}
+TMapTypeEntry& TMapTypeEntry::operator=(const TMapTypeEntry& other18) {
+ keyTypePtr = other18.keyTypePtr;
+ valueTypePtr = other18.valueTypePtr;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TMapTypeEntry(";
+ out << "keyTypePtr=" << to_string(obj.keyTypePtr);
+ out << ", " << "valueTypePtr=" << to_string(obj.valueTypePtr);
+ out << ")";
+ return out;
+}
+
+
+TStructTypeEntry::~TStructTypeEntry() throw() {
+}
+
+
+void TStructTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) {
+ this->nameToTypePtr = val;
+}
+
const char* TStructTypeEntry::ascii_fingerprint = "91F548CA159B4AB4291F5741AC161402";
const uint8_t TStructTypeEntry::binary_fingerprint[16] = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02};
@@ -680,17 +850,17 @@ uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->nameToTypePtr.clear();
- uint32_t _size9;
- ::apache::thrift::protocol::TType _ktype10;
- ::apache::thrift::protocol::TType _vtype11;
- xfer += iprot->readMapBegin(_ktype10, _vtype11, _size9);
- uint32_t _i13;
- for (_i13 = 0; _i13 < _size9; ++_i13)
+ uint32_t _size19;
+ ::apache::thrift::protocol::TType _ktype20;
+ ::apache::thrift::protocol::TType _vtype21;
+ xfer += iprot->readMapBegin(_ktype20, _vtype21, _size19);
+ uint32_t _i23;
+ for (_i23 = 0; _i23 < _size19; ++_i23)
{
- std::string _key14;
- xfer += iprot->readString(_key14);
- TTypeEntryPtr& _val15 = this->nameToTypePtr[_key14];
- xfer += iprot->readI32(_val15);
+ std::string _key24;
+ xfer += iprot->readString(_key24);
+ TTypeEntryPtr& _val25 = this->nameToTypePtr[_key24];
+ xfer += iprot->readI32(_val25);
}
xfer += iprot->readMapEnd();
}
@@ -715,16 +885,17 @@ uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TStructTypeEntry");
xfer += oprot->writeFieldBegin("nameToTypePtr", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->nameToTypePtr.size()));
- std::map<std::string, TTypeEntryPtr> ::const_iterator _iter16;
- for (_iter16 = this->nameToTypePtr.begin(); _iter16 != this->nameToTypePtr.end(); ++_iter16)
+ std::map<std::string, TTypeEntryPtr> ::const_iterator _iter26;
+ for (_iter26 = this->nameToTypePtr.begin(); _iter26 != this->nameToTypePtr.end(); ++_iter26)
{
- xfer += oprot->writeString(_iter16->first);
- xfer += oprot->writeI32(_iter16->second);
+ xfer += oprot->writeString(_iter26->first);
+ xfer += oprot->writeI32(_iter26->second);
}
xfer += oprot->writeMapEnd();
}
@@ -732,6 +903,7 @@ uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -740,6 +912,30 @@ void swap(TStructTypeEntry &a, TStructTypeEntry &b) {
swap(a.nameToTypePtr, b.nameToTypePtr);
}
+TStructTypeEntry::TStructTypeEntry(const TStructTypeEntry& other27) {
+ nameToTypePtr = other27.nameToTypePtr;
+}
+TStructTypeEntry& TStructTypeEntry::operator=(const TStructTypeEntry& other28) {
+ nameToTypePtr = other28.nameToTypePtr;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TStructTypeEntry(";
+ out << "nameToTypePtr=" << to_string(obj.nameToTypePtr);
+ out << ")";
+ return out;
+}
+
+
+TUnionTypeEntry::~TUnionTypeEntry() throw() {
+}
+
+
+void TUnionTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) {
+ this->nameToTypePtr = val;
+}
+
const char* TUnionTypeEntry::ascii_fingerprint = "91F548CA159B4AB4291F5741AC161402";
const uint8_t TUnionTypeEntry::binary_fingerprint[16] = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02};
@@ -768,17 +964,17 @@ uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->nameToTypePtr.clear();
- uint32_t _size17;
- ::apache::thrift::protocol::TType _ktype18;
- ::apache::thrift::protocol::TType _vtype19;
- xfer += iprot->readMapBegin(_ktype18, _vtype19, _size17);
- uint32_t _i21;
- for (_i21 = 0; _i21 < _size17; ++_i21)
+ uint32_t _size29;
+ ::apache::thrift::protocol::TType _ktype30;
+ ::apache::thrift::protocol::TType _vtype31;
+ xfer += iprot->readMapBegin(_ktype30, _vtype31, _size29);
+ uint32_t _i33;
+ for (_i33 = 0; _i33 < _size29; ++_i33)
{
- std::string _key22;
- xfer += iprot->readString(_key22);
- TTypeEntryPtr& _val23 = this->nameToTypePtr[_key22];
- xfer += iprot->readI32(_val23);
+ std::string _key34;
+ xfer += iprot->readString(_key34);
+ TTypeEntryPtr& _val35 = this->nameToTypePtr[_key34];
+ xfer += iprot->readI32(_val35);
}
xfer += iprot->readMapEnd();
}
@@ -803,16 +999,17 @@ uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TUnionTypeEntry");
xfer += oprot->writeFieldBegin("nameToTypePtr", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->nameToTypePtr.size()));
- std::map<std::string, TTypeEntryPtr> ::const_iterator _iter24;
- for (_iter24 = this->nameToTypePtr.begin(); _iter24 != this->nameToTypePtr.end(); ++_iter24)
+ std::map<std::string, TTypeEntryPtr> ::const_iterator _iter36;
+ for (_iter36 = this->nameToTypePtr.begin(); _iter36 != this->nameToTypePtr.end(); ++_iter36)
{
- xfer += oprot->writeString(_iter24->first);
- xfer += oprot->writeI32(_iter24->second);
+ xfer += oprot->writeString(_iter36->first);
+ xfer += oprot->writeI32(_iter36->second);
}
xfer += oprot->writeMapEnd();
}
@@ -820,6 +1017,7 @@ uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) co
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -828,6 +1026,30 @@ void swap(TUnionTypeEntry &a, TUnionTypeEntry &b) {
swap(a.nameToTypePtr, b.nameToTypePtr);
}
+TUnionTypeEntry::TUnionTypeEntry(const TUnionTypeEntry& other37) {
+ nameToTypePtr = other37.nameToTypePtr;
+}
+TUnionTypeEntry& TUnionTypeEntry::operator=(const TUnionTypeEntry& other38) {
+ nameToTypePtr = other38.nameToTypePtr;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TUnionTypeEntry(";
+ out << "nameToTypePtr=" << to_string(obj.nameToTypePtr);
+ out << ")";
+ return out;
+}
+
+
+TUserDefinedTypeEntry::~TUserDefinedTypeEntry() throw() {
+}
+
+
+void TUserDefinedTypeEntry::__set_typeClassName(const std::string& val) {
+ this->typeClassName = val;
+}
+
const char* TUserDefinedTypeEntry::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
const uint8_t TUserDefinedTypeEntry::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
@@ -876,6 +1098,7 @@ uint32_t TUserDefinedTypeEntry::read(::apache::thrift::protocol::TProtocol* ipro
uint32_t TUserDefinedTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TUserDefinedTypeEntry");
xfer += oprot->writeFieldBegin("typeClassName", ::apache::thrift::protocol::T_STRING, 1);
@@ -884,6 +1107,7 @@ uint32_t TUserDefinedTypeEntry::write(::apache::thrift::protocol::TProtocol* opr
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -892,6 +1116,50 @@ void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b) {
swap(a.typeClassName, b.typeClassName);
}
+TUserDefinedTypeEntry::TUserDefinedTypeEntry(const TUserDefinedTypeEntry& other39) {
+ typeClassName = other39.typeClassName;
+}
+TUserDefinedTypeEntry& TUserDefinedTypeEntry::operator=(const TUserDefinedTypeEntry& other40) {
+ typeClassName = other40.typeClassName;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TUserDefinedTypeEntry(";
+ out << "typeClassName=" << to_string(obj.typeClassName);
+ out << ")";
+ return out;
+}
+
+
+TTypeEntry::~TTypeEntry() throw() {
+}
+
+
+void TTypeEntry::__set_primitiveEntry(const TPrimitiveTypeEntry& val) {
+ this->primitiveEntry = val;
+}
+
+void TTypeEntry::__set_arrayEntry(const TArrayTypeEntry& val) {
+ this->arrayEntry = val;
+}
+
+void TTypeEntry::__set_mapEntry(const TMapTypeEntry& val) {
+ this->mapEntry = val;
+}
+
+void TTypeEntry::__set_structEntry(const TStructTypeEntry& val) {
+ this->structEntry = val;
+}
+
+void TTypeEntry::__set_unionEntry(const TUnionTypeEntry& val) {
+ this->unionEntry = val;
+}
+
+void TTypeEntry::__set_userDefinedTypeEntry(const TUserDefinedTypeEntry& val) {
+ this->userDefinedTypeEntry = val;
+}
+
const char* TTypeEntry::ascii_fingerprint = "2FE56D9097E325DAA7E933738C6D325F";
const uint8_t TTypeEntry::binary_fingerprint[16] = {0x2F,0xE5,0x6D,0x90,0x97,0xE3,0x25,0xDA,0xA7,0xE9,0x33,0x73,0x8C,0x6D,0x32,0x5F};
@@ -977,6 +1245,7 @@ uint32_t TTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TTypeEntry");
xfer += oprot->writeFieldBegin("primitiveEntry", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -1005,6 +1274,7 @@ uint32_t TTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1019,6 +1289,47 @@ void swap(TTypeEntry &a, TTypeEntry &b) {
swap(a.__isset, b.__isset);
}
+TTypeEntry::TTypeEntry(const TTypeEntry& other41) {
+ primitiveEntry = other41.primitiveEntry;
+ arrayEntry = other41.arrayEntry;
+ mapEntry = other41.mapEntry;
+ structEntry = other41.structEntry;
+ unionEntry = other41.unionEntry;
+ userDefinedTypeEntry = other41.userDefinedTypeEntry;
+ __isset = other41.__isset;
+}
+TTypeEntry& TTypeEntry::operator=(const TTypeEntry& other42) {
+ primitiveEntry = other42.primitiveEntry;
+ arrayEntry = other42.arrayEntry;
+ mapEntry = other42.mapEntry;
+ structEntry = other42.structEntry;
+ unionEntry = other42.unionEntry;
+ userDefinedTypeEntry = other42.userDefinedTypeEntry;
+ __isset = other42.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj) {
+ using apache::thrift::to_string;
+ out << "TTypeEntry(";
+ out << "primitiveEntry=" << to_string(obj.primitiveEntry);
+ out << ", " << "arrayEntry=" << to_string(obj.arrayEntry);
+ out << ", " << "mapEntry=" << to_string(obj.mapEntry);
+ out << ", " << "structEntry=" << to_string(obj.structEntry);
+ out << ", " << "unionEntry=" << to_string(obj.unionEntry);
+ out << ", " << "userDefinedTypeEntry=" << to_string(obj.userDefinedTypeEntry);
+ out << ")";
+ return out;
+}
+
+
+TTypeDesc::~TTypeDesc() throw() {
+}
+
+
+void TTypeDesc::__set_types(const std::vector<TTypeEntry> & val) {
+ this->types = val;
+}
+
const char* TTypeDesc::ascii_fingerprint = "90B3C5A0B73419A84E85E0E48C452AA5";
const uint8_t TTypeDesc::binary_fingerprint[16] = {0x90,0xB3,0xC5,0xA0,0xB7,0x34,0x19,0xA8,0x4E,0x85,0xE0,0xE4,0x8C,0x45,0x2A,0xA5};
@@ -1047,14 +1358,14 @@ uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->types.clear();
- uint32_t _size25;
- ::apache::thrift::protocol::TType _etype28;
- xfer += iprot->readListBegin(_etype28, _size25);
- this->types.resize(_size25);
- uint32_t _i29;
- for (_i29 = 0; _i29 < _size25; ++_i29)
+ uint32_t _size43;
+ ::apache::thrift::protocol::TType _etype46;
+ xfer += iprot->readListBegin(_etype46, _size43);
+ this->types.resize(_size43);
+ uint32_t _i47;
+ for (_i47 = 0; _i47 < _size43; ++_i47)
{
- xfer += this->types[_i29].read(iprot);
+ xfer += this->types[_i47].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -1079,15 +1390,16 @@ uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TTypeDesc");
xfer += oprot->writeFieldBegin("types", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->types.size()));
- std::vector<TTypeEntry> ::const_iterator _iter30;
- for (_iter30 = this->types.begin(); _iter30 != this->types.end(); ++_iter30)
+ std::vector<TTypeEntry> ::const_iterator _iter48;
+ for (_iter48 = this->types.begin(); _iter48 != this->types.end(); ++_iter48)
{
- xfer += (*_iter30).write(oprot);
+ xfer += (*_iter48).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -1095,6 +1407,7 @@ uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1103,6 +1416,43 @@ void swap(TTypeDesc &a, TTypeDesc &b) {
swap(a.types, b.types);
}
+TTypeDesc::TTypeDesc(const TTypeDesc& other49) {
+ types = other49.types;
+}
+TTypeDesc& TTypeDesc::operator=(const TTypeDesc& other50) {
+ types = other50.types;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj) {
+ using apache::thrift::to_string;
+ out << "TTypeDesc(";
+ out << "types=" << to_string(obj.types);
+ out << ")";
+ return out;
+}
+
+
+TColumnDesc::~TColumnDesc() throw() {
+}
+
+
+void TColumnDesc::__set_columnName(const std::string& val) {
+ this->columnName = val;
+}
+
+void TColumnDesc::__set_typeDesc(const TTypeDesc& val) {
+ this->typeDesc = val;
+}
+
+void TColumnDesc::__set_position(const int32_t val) {
+ this->position = val;
+}
+
+void TColumnDesc::__set_comment(const std::string& val) {
+ this->comment = val;
+__isset.comment = true;
+}
+
const char* TColumnDesc::ascii_fingerprint = "EABED9009D5FCABFCA65612069F2A849";
const uint8_t TColumnDesc::binary_fingerprint[16] = {0xEA,0xBE,0xD9,0x00,0x9D,0x5F,0xCA,0xBF,0xCA,0x65,0x61,0x20,0x69,0xF2,0xA8,0x49};
@@ -1181,6 +1531,7 @@ uint32_t TColumnDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TColumnDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TColumnDesc");
xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 1);
@@ -1202,6 +1553,7 @@ uint32_t TColumnDesc::write(::apache::thrift::protocol::TProtocol* oprot) const
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1214,6 +1566,41 @@ void swap(TColumnDesc &a, TColumnDesc &b) {
swap(a.__isset, b.__isset);
}
+TColumnDesc::TColumnDesc(const TColumnDesc& other51) {
+ columnName = other51.columnName;
+ typeDesc = other51.typeDesc;
+ position = other51.position;
+ comment = other51.comment;
+ __isset = other51.__isset;
+}
+TColumnDesc& TColumnDesc::operator=(const TColumnDesc& other52) {
+ columnName = other52.columnName;
+ typeDesc = other52.typeDesc;
+ position = other52.position;
+ comment = other52.comment;
+ __isset = other52.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj) {
+ using apache::thrift::to_string;
+ out << "TColumnDesc(";
+ out << "columnName=" << to_string(obj.columnName);
+ out << ", " << "typeDesc=" << to_string(obj.typeDesc);
+ out << ", " << "position=" << to_string(obj.position);
+ out << ", " << "comment="; (obj.__isset.comment ? (out << to_string(obj.comment)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TTableSchema::~TTableSchema() throw() {
+}
+
+
+void TTableSchema::__set_columns(const std::vector<TColumnDesc> & val) {
+ this->columns = val;
+}
+
const char* TTableSchema::ascii_fingerprint = "7A1811E49313E5977107FC667B20E39D";
const uint8_t TTableSchema::binary_fingerprint[16] = {0x7A,0x18,0x11,0xE4,0x93,0x13,0xE5,0x97,0x71,0x07,0xFC,0x66,0x7B,0x20,0xE3,0x9D};
@@ -1242,14 +1629,14 @@ uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->columns.clear();
- uint32_t _size31;
- ::apache::thrift::protocol::TType _etype34;
- xfer += iprot->readListBegin(_etype34, _size31);
- this->columns.resize(_size31);
- uint32_t _i35;
- for (_i35 = 0; _i35 < _size31; ++_i35)
+ uint32_t _size53;
+ ::apache::thrift::protocol::TType _etype56;
+ xfer += iprot->readListBegin(_etype56, _size53);
+ this->columns.resize(_size53);
+ uint32_t _i57;
+ for (_i57 = 0; _i57 < _size53; ++_i57)
{
- xfer += this->columns[_i35].read(iprot);
+ xfer += this->columns[_i57].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -1274,15 +1661,16 @@ uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TTableSchema");
xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
- std::vector<TColumnDesc> ::const_iterator _iter36;
- for (_iter36 = this->columns.begin(); _iter36 != this->columns.end(); ++_iter36)
+ std::vector<TColumnDesc> ::const_iterator _iter58;
+ for (_iter58 = this->columns.begin(); _iter58 != this->columns.end(); ++_iter58)
{
- xfer += (*_iter36).write(oprot);
+ xfer += (*_iter58).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -1290,6 +1678,7 @@ uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1298,6 +1687,31 @@ void swap(TTableSchema &a, TTableSchema &b) {
swap(a.columns, b.columns);
}
+TTableSchema::TTableSchema(const TTableSchema& other59) {
+ columns = other59.columns;
+}
+TTableSchema& TTableSchema::operator=(const TTableSchema& other60) {
+ columns = other60.columns;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TTableSchema& obj) {
+ using apache::thrift::to_string;
+ out << "TTableSchema(";
+ out << "columns=" << to_string(obj.columns);
+ out << ")";
+ return out;
+}
+
+
+TBoolValue::~TBoolValue() throw() {
+}
+
+
+void TBoolValue::__set_value(const bool val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TBoolValue::ascii_fingerprint = "BF054652DEF86253C2BEE7D947F167DD";
const uint8_t TBoolValue::binary_fingerprint[16] = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
@@ -1343,6 +1757,7 @@ uint32_t TBoolValue::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TBoolValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TBoolValue");
if (this->__isset.value) {
@@ -1352,6 +1767,7 @@ uint32_t TBoolValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1361,6 +1777,33 @@ void swap(TBoolValue &a, TBoolValue &b) {
swap(a.__isset, b.__isset);
}
+TBoolValue::TBoolValue(const TBoolValue& other61) {
+ value = other61.value;
+ __isset = other61.__isset;
+}
+TBoolValue& TBoolValue::operator=(const TBoolValue& other62) {
+ value = other62.value;
+ __isset = other62.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TBoolValue& obj) {
+ using apache::thrift::to_string;
+ out << "TBoolValue(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TByteValue::~TByteValue() throw() {
+}
+
+
+void TByteValue::__set_value(const int8_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TByteValue::ascii_fingerprint = "9C15298ACB5D04AEA9B52D5DDE6F9208";
const uint8_t TByteValue::binary_fingerprint[16] = {0x9C,0x15,0x29,0x8A,0xCB,0x5D,0x04,0xAE,0xA9,0xB5,0x2D,0x5D,0xDE,0x6F,0x92,0x08};
@@ -1406,6 +1849,7 @@ uint32_t TByteValue::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TByteValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TByteValue");
if (this->__isset.value) {
@@ -1415,6 +1859,7 @@ uint32_t TByteValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1424,6 +1869,33 @@ void swap(TByteValue &a, TByteValue &b) {
swap(a.__isset, b.__isset);
}
+TByteValue::TByteValue(const TByteValue& other63) {
+ value = other63.value;
+ __isset = other63.__isset;
+}
+TByteValue& TByteValue::operator=(const TByteValue& other64) {
+ value = other64.value;
+ __isset = other64.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TByteValue& obj) {
+ using apache::thrift::to_string;
+ out << "TByteValue(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TI16Value::~TI16Value() throw() {
+}
+
+
+void TI16Value::__set_value(const int16_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TI16Value::ascii_fingerprint = "5DAC9C51C7E1106BF936FC71860BE9D5";
const uint8_t TI16Value::binary_fingerprint[16] = {0x5D,0xAC,0x9C,0x51,0xC7,0xE1,0x10,0x6B,0xF9,0x36,0xFC,0x71,0x86,0x0B,0xE9,0xD5};
@@ -1469,6 +1941,7 @@ uint32_t TI16Value::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TI16Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TI16Value");
if (this->__isset.value) {
@@ -1478,6 +1951,7 @@ uint32_t TI16Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1487,6 +1961,33 @@ void swap(TI16Value &a, TI16Value &b) {
swap(a.__isset, b.__isset);
}
+TI16Value::TI16Value(const TI16Value& other65) {
+ value = other65.value;
+ __isset = other65.__isset;
+}
+TI16Value& TI16Value::operator=(const TI16Value& other66) {
+ value = other66.value;
+ __isset = other66.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TI16Value& obj) {
+ using apache::thrift::to_string;
+ out << "TI16Value(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TI32Value::~TI32Value() throw() {
+}
+
+
+void TI32Value::__set_value(const int32_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TI32Value::ascii_fingerprint = "E7A96B151330359E84C0A3AC91BCBACD";
const uint8_t TI32Value::binary_fingerprint[16] = {0xE7,0xA9,0x6B,0x15,0x13,0x30,0x35,0x9E,0x84,0xC0,0xA3,0xAC,0x91,0xBC,0xBA,0xCD};
@@ -1532,6 +2033,7 @@ uint32_t TI32Value::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TI32Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TI32Value");
if (this->__isset.value) {
@@ -1541,6 +2043,7 @@ uint32_t TI32Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1550,6 +2053,33 @@ void swap(TI32Value &a, TI32Value &b) {
swap(a.__isset, b.__isset);
}
+TI32Value::TI32Value(const TI32Value& other67) {
+ value = other67.value;
+ __isset = other67.__isset;
+}
+TI32Value& TI32Value::operator=(const TI32Value& other68) {
+ value = other68.value;
+ __isset = other68.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TI32Value& obj) {
+ using apache::thrift::to_string;
+ out << "TI32Value(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TI64Value::~TI64Value() throw() {
+}
+
+
+void TI64Value::__set_value(const int64_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TI64Value::ascii_fingerprint = "148F3AAAC1D9859963D5E800D187BF26";
const uint8_t TI64Value::binary_fingerprint[16] = {0x14,0x8F,0x3A,0xAA,0xC1,0xD9,0x85,0x99,0x63,0xD5,0xE8,0x00,0xD1,0x87,0xBF,0x26};
@@ -1595,6 +2125,7 @@ uint32_t TI64Value::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TI64Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TI64Value");
if (this->__isset.value) {
@@ -1604,6 +2135,7 @@ uint32_t TI64Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1613,6 +2145,33 @@ void swap(TI64Value &a, TI64Value &b) {
swap(a.__isset, b.__isset);
}
+TI64Value::TI64Value(const TI64Value& other69) {
+ value = other69.value;
+ __isset = other69.__isset;
+}
+TI64Value& TI64Value::operator=(const TI64Value& other70) {
+ value = other70.value;
+ __isset = other70.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TI64Value& obj) {
+ using apache::thrift::to_string;
+ out << "TI64Value(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TDoubleValue::~TDoubleValue() throw() {
+}
+
+
+void TDoubleValue::__set_value(const double val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TDoubleValue::ascii_fingerprint = "3586E570A474C4A8603B4FF74903B3A6";
const uint8_t TDoubleValue::binary_fingerprint[16] = {0x35,0x86,0xE5,0x70,0xA4,0x74,0xC4,0xA8,0x60,0x3B,0x4F,0xF7,0x49,0x03,0xB3,0xA6};
@@ -1658,6 +2217,7 @@ uint32_t TDoubleValue::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TDoubleValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TDoubleValue");
if (this->__isset.value) {
@@ -1667,6 +2227,7 @@ uint32_t TDoubleValue::write(::apache::thrift::protocol::TProtocol* oprot) const
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1676,6 +2237,33 @@ void swap(TDoubleValue &a, TDoubleValue &b) {
swap(a.__isset, b.__isset);
}
+TDoubleValue::TDoubleValue(const TDoubleValue& other71) {
+ value = other71.value;
+ __isset = other71.__isset;
+}
+TDoubleValue& TDoubleValue::operator=(const TDoubleValue& other72) {
+ value = other72.value;
+ __isset = other72.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj) {
+ using apache::thrift::to_string;
+ out << "TDoubleValue(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TStringValue::~TStringValue() throw() {
+}
+
+
+void TStringValue::__set_value(const std::string& val) {
+ this->value = val;
+__isset.value = true;
+}
+
const char* TStringValue::ascii_fingerprint = "66E694018C17E5B65A59AE8F55CCA3CD";
const uint8_t TStringValue::binary_fingerprint[16] = {0x66,0xE6,0x94,0x01,0x8C,0x17,0xE5,0xB6,0x5A,0x59,0xAE,0x8F,0x55,0xCC,0xA3,0xCD};
@@ -1721,6 +2309,7 @@ uint32_t TStringValue::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TStringValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TStringValue");
if (this->__isset.value) {
@@ -1730,6 +2319,7 @@ uint32_t TStringValue::write(::apache::thrift::protocol::TProtocol* oprot) const
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1739,6 +2329,56 @@ void swap(TStringValue &a, TStringValue &b) {
swap(a.__isset, b.__isset);
}
+TStringValue::TStringValue(const TStringValue& other73) {
+ value = other73.value;
+ __isset = other73.__isset;
+}
+TStringValue& TStringValue::operator=(const TStringValue& other74) {
+ value = other74.value;
+ __isset = other74.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TStringValue& obj) {
+ using apache::thrift::to_string;
+ out << "TStringValue(";
+ out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TColumnValue::~TColumnValue() throw() {
+}
+
+
+void TColumnValue::__set_boolVal(const TBoolValue& val) {
+ this->boolVal = val;
+}
+
+void TColumnValue::__set_byteVal(const TByteValue& val) {
+ this->byteVal = val;
+}
+
+void TColumnValue::__set_i16Val(const TI16Value& val) {
+ this->i16Val = val;
+}
+
+void TColumnValue::__set_i32Val(const TI32Value& val) {
+ this->i32Val = val;
+}
+
+void TColumnValue::__set_i64Val(const TI64Value& val) {
+ this->i64Val = val;
+}
+
+void TColumnValue::__set_doubleVal(const TDoubleValue& val) {
+ this->doubleVal = val;
+}
+
+void TColumnValue::__set_stringVal(const TStringValue& val) {
+ this->stringVal = val;
+}
+
const char* TColumnValue::ascii_fingerprint = "C2DDD988447EA7999A8285AA38AAE9AD";
const uint8_t TColumnValue::binary_fingerprint[16] = {0xC2,0xDD,0xD9,0x88,0x44,0x7E,0xA7,0x99,0x9A,0x82,0x85,0xAA,0x38,0xAA,0xE9,0xAD};
@@ -1832,6 +2472,7 @@ uint32_t TColumnValue::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TColumnValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TColumnValue");
xfer += oprot->writeFieldBegin("boolVal", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -1864,6 +2505,7 @@ uint32_t TColumnValue::write(::apache::thrift::protocol::TProtocol* oprot) const
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1879,6 +2521,50 @@ void swap(TColumnValue &a, TColumnValue &b) {
swap(a.__isset, b.__isset);
}
+TColumnValue::TColumnValue(const TColumnValue& other75) {
+ boolVal = other75.boolVal;
+ byteVal = other75.byteVal;
+ i16Val = other75.i16Val;
+ i32Val = other75.i32Val;
+ i64Val = other75.i64Val;
+ doubleVal = other75.doubleVal;
+ stringVal = other75.stringVal;
+ __isset = other75.__isset;
+}
+TColumnValue& TColumnValue::operator=(const TColumnValue& other76) {
+ boolVal = other76.boolVal;
+ byteVal = other76.byteVal;
+ i16Val = other76.i16Val;
+ i32Val = other76.i32Val;
+ i64Val = other76.i64Val;
+ doubleVal = other76.doubleVal;
+ stringVal = other76.stringVal;
+ __isset = other76.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TColumnValue& obj) {
+ using apache::thrift::to_string;
+ out << "TColumnValue(";
+ out << "boolVal=" << to_string(obj.boolVal);
+ out << ", " << "byteVal=" << to_string(obj.byteVal);
+ out << ", " << "i16Val=" << to_string(obj.i16Val);
+ out << ", " << "i32Val=" << to_string(obj.i32Val);
+ out << ", " << "i64Val=" << to_string(obj.i64Val);
+ out << ", " << "doubleVal=" << to_string(obj.doubleVal);
+ out << ", " << "stringVal=" << to_string(obj.stringVal);
+ out << ")";
+ return out;
+}
+
+
+TRow::~TRow() throw() {
+}
+
+
+void TRow::__set_colVals(const std::vector<TColumnValue> & val) {
+ this->colVals = val;
+}
+
const char* TRow::ascii_fingerprint = "E73FD1FCA0CA58A669FC3E02FB68D534";
const uint8_t TRow::binary_fingerprint[16] = {0xE7,0x3F,0xD1,0xFC,0xA0,0xCA,0x58,0xA6,0x69,0xFC,0x3E,0x02,0xFB,0x68,0xD5,0x34};
@@ -1907,14 +2593,14 @@ uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colVals.clear();
- uint32_t _size37;
- ::apache::thrift::protocol::TType _etype40;
- xfer += iprot->readListBegin(_etype40, _size37);
- this->colVals.resize(_size37);
- uint32_t _i41;
- for (_i41 = 0; _i41 < _size37; ++_i41)
+ uint32_t _size77;
+ ::apache::thrift::protocol::TType _etype80;
+ xfer += iprot->readListBegin(_etype80, _size77);
+ this->colVals.resize(_size77);
+ uint32_t _i81;
+ for (_i81 = 0; _i81 < _size77; ++_i81)
{
- xfer += this->colVals[_i41].read(iprot);
+ xfer += this->colVals[_i81].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -1939,15 +2625,16 @@ uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TRow");
xfer += oprot->writeFieldBegin("colVals", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colVals.size()));
- std::vector<TColumnValue> ::const_iterator _iter42;
- for (_iter42 = this->colVals.begin(); _iter42 != this->colVals.end(); ++_iter42)
+ std::vector<TColumnValue> ::const_iterator _iter82;
+ for (_iter82 = this->colVals.begin(); _iter82 != this->colVals.end(); ++_iter82)
{
- xfer += (*_iter42).write(oprot);
+ xfer += (*_iter82).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -1955,6 +2642,7 @@ uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -1963,15 +2651,43 @@ void swap(TRow &a, TRow &b) {
swap(a.colVals, b.colVals);
}
-const char* TBoolColumn::ascii_fingerprint = "F9058324D96DB7F974D8ACDC01C54219";
-const uint8_t TBoolColumn::binary_fingerprint[16] = {0xF9,0x05,0x83,0x24,0xD9,0x6D,0xB7,0xF9,0x74,0xD8,0xAC,0xDC,0x01,0xC5,0x42,0x19};
+TRow::TRow(const TRow& other83) {
+ colVals = other83.colVals;
+}
+TRow& TRow::operator=(const TRow& other84) {
+ colVals = other84.colVals;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TRow& obj) {
+ using apache::thrift::to_string;
+ out << "TRow(";
+ out << "colVals=" << to_string(obj.colVals);
+ out << ")";
+ return out;
+}
-uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
- uint32_t xfer = 0;
- std::string fname;
- ::apache::thrift::protocol::TType ftype;
- int16_t fid;
+TBoolColumn::~TBoolColumn() throw() {
+}
+
+
+void TBoolColumn::__set_values(const std::vector<bool> & val) {
+ this->values = val;
+}
+
+void TBoolColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
+const char* TBoolColumn::ascii_fingerprint = "F9058324D96DB7F974D8ACDC01C54219";
+const uint8_t TBoolColumn::binary_fingerprint[16] = {0xF9,0x05,0x83,0x24,0xD9,0x6D,0xB7,0xF9,0x74,0xD8,0xAC,0xDC,0x01,0xC5,0x42,0x19};
+
+uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
xfer += iprot->readStructBegin(fname);
@@ -1992,14 +2708,14 @@ uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size43;
- ::apache::thrift::protocol::TType _etype46;
- xfer += iprot->readListBegin(_etype46, _size43);
- this->values.resize(_size43);
- uint32_t _i47;
- for (_i47 = 0; _i47 < _size43; ++_i47)
+ uint32_t _size85;
+ ::apache::thrift::protocol::TType _etype88;
+ xfer += iprot->readListBegin(_etype88, _size85);
+ this->values.resize(_size85);
+ uint32_t _i89;
+ for (_i89 = 0; _i89 < _size85; ++_i89)
{
- xfer += iprot->readBool(this->values[_i47]);
+ xfer += iprot->readBool(this->values[_i89]);
}
xfer += iprot->readListEnd();
}
@@ -2034,15 +2750,16 @@ uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TBoolColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TBoolColumn");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->values.size()));
- std::vector<bool> ::const_iterator _iter48;
- for (_iter48 = this->values.begin(); _iter48 != this->values.end(); ++_iter48)
+ std::vector<bool> ::const_iterator _iter90;
+ for (_iter90 = this->values.begin(); _iter90 != this->values.end(); ++_iter90)
{
- xfer += oprot->writeBool((*_iter48));
+ xfer += oprot->writeBool((*_iter90));
}
xfer += oprot->writeListEnd();
}
@@ -2054,6 +2771,7 @@ uint32_t TBoolColumn::write(::apache::thrift::protocol::TProtocol* oprot) const
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2063,6 +2781,37 @@ void swap(TBoolColumn &a, TBoolColumn &b) {
swap(a.nulls, b.nulls);
}
+TBoolColumn::TBoolColumn(const TBoolColumn& other91) {
+ values = other91.values;
+ nulls = other91.nulls;
+}
+TBoolColumn& TBoolColumn::operator=(const TBoolColumn& other92) {
+ values = other92.values;
+ nulls = other92.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj) {
+ using apache::thrift::to_string;
+ out << "TBoolColumn(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TByteColumn::~TByteColumn() throw() {
+}
+
+
+void TByteColumn::__set_values(const std::vector<int8_t> & val) {
+ this->values = val;
+}
+
+void TByteColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TByteColumn::ascii_fingerprint = "1CB300106BAA463A70BB2A2395900F48";
const uint8_t TByteColumn::binary_fingerprint[16] = {0x1C,0xB3,0x00,0x10,0x6B,0xAA,0x46,0x3A,0x70,0xBB,0x2A,0x23,0x95,0x90,0x0F,0x48};
@@ -2092,14 +2841,14 @@ uint32_t TByteColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size49;
- ::apache::thrift::protocol::TType _etype52;
- xfer += iprot->readListBegin(_etype52, _size49);
- this->values.resize(_size49);
- uint32_t _i53;
- for (_i53 = 0; _i53 < _size49; ++_i53)
+ uint32_t _size93;
+ ::apache::thrift::protocol::TType _etype96;
+ xfer += iprot->readListBegin(_etype96, _size93);
+ this->values.resize(_size93);
+ uint32_t _i97;
+ for (_i97 = 0; _i97 < _size93; ++_i97)
{
- xfer += iprot->readByte(this->values[_i53]);
+ xfer += iprot->readByte(this->values[_i97]);
}
xfer += iprot->readListEnd();
}
@@ -2134,15 +2883,16 @@ uint32_t TByteColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TByteColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TByteColumn");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BYTE, static_cast<uint32_t>(this->values.size()));
- std::vector<int8_t> ::const_iterator _iter54;
- for (_iter54 = this->values.begin(); _iter54 != this->values.end(); ++_iter54)
+ std::vector<int8_t> ::const_iterator _iter98;
+ for (_iter98 = this->values.begin(); _iter98 != this->values.end(); ++_iter98)
{
- xfer += oprot->writeByte((*_iter54));
+ xfer += oprot->writeByte((*_iter98));
}
xfer += oprot->writeListEnd();
}
@@ -2154,6 +2904,7 @@ uint32_t TByteColumn::write(::apache::thrift::protocol::TProtocol* oprot) const
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2163,6 +2914,37 @@ void swap(TByteColumn &a, TByteColumn &b) {
swap(a.nulls, b.nulls);
}
+TByteColumn::TByteColumn(const TByteColumn& other99) {
+ values = other99.values;
+ nulls = other99.nulls;
+}
+TByteColumn& TByteColumn::operator=(const TByteColumn& other100) {
+ values = other100.values;
+ nulls = other100.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TByteColumn& obj) {
+ using apache::thrift::to_string;
+ out << "TByteColumn(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TI16Column::~TI16Column() throw() {
+}
+
+
+void TI16Column::__set_values(const std::vector<int16_t> & val) {
+ this->values = val;
+}
+
+void TI16Column::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TI16Column::ascii_fingerprint = "6574CDB1F121C8DB47FB257A3F104BDB";
const uint8_t TI16Column::binary_fingerprint[16] = {0x65,0x74,0xCD,0xB1,0xF1,0x21,0xC8,0xDB,0x47,0xFB,0x25,0x7A,0x3F,0x10,0x4B,0xDB};
@@ -2192,14 +2974,14 @@ uint32_t TI16Column::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size55;
- ::apache::thrift::protocol::TType _etype58;
- xfer += iprot->readListBegin(_etype58, _size55);
- this->values.resize(_size55);
- uint32_t _i59;
- for (_i59 = 0; _i59 < _size55; ++_i59)
+ uint32_t _size101;
+ ::apache::thrift::protocol::TType _etype104;
+ xfer += iprot->readListBegin(_etype104, _size101);
+ this->values.resize(_size101);
+ uint32_t _i105;
+ for (_i105 = 0; _i105 < _size101; ++_i105)
{
- xfer += iprot->readI16(this->values[_i59]);
+ xfer += iprot->readI16(this->values[_i105]);
}
xfer += iprot->readListEnd();
}
@@ -2234,15 +3016,16 @@ uint32_t TI16Column::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TI16Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TI16Column");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I16, static_cast<uint32_t>(this->values.size()));
- std::vector<int16_t> ::const_iterator _iter60;
- for (_iter60 = this->values.begin(); _iter60 != this->values.end(); ++_iter60)
+ std::vector<int16_t> ::const_iterator _iter106;
+ for (_iter106 = this->values.begin(); _iter106 != this->values.end(); ++_iter106)
{
- xfer += oprot->writeI16((*_iter60));
+ xfer += oprot->writeI16((*_iter106));
}
xfer += oprot->writeListEnd();
}
@@ -2254,6 +3037,7 @@ uint32_t TI16Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2263,6 +3047,37 @@ void swap(TI16Column &a, TI16Column &b) {
swap(a.nulls, b.nulls);
}
+TI16Column::TI16Column(const TI16Column& other107) {
+ values = other107.values;
+ nulls = other107.nulls;
+}
+TI16Column& TI16Column::operator=(const TI16Column& other108) {
+ values = other108.values;
+ nulls = other108.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TI16Column& obj) {
+ using apache::thrift::to_string;
+ out << "TI16Column(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TI32Column::~TI32Column() throw() {
+}
+
+
+void TI32Column::__set_values(const std::vector<int32_t> & val) {
+ this->values = val;
+}
+
+void TI32Column::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TI32Column::ascii_fingerprint = "CCCCE89C7E9DA10280F5663700677313";
const uint8_t TI32Column::binary_fingerprint[16] = {0xCC,0xCC,0xE8,0x9C,0x7E,0x9D,0xA1,0x02,0x80,0xF5,0x66,0x37,0x00,0x67,0x73,0x13};
@@ -2292,14 +3107,14 @@ uint32_t TI32Column::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size61;
- ::apache::thrift::protocol::TType _etype64;
- xfer += iprot->readListBegin(_etype64, _size61);
- this->values.resize(_size61);
- uint32_t _i65;
- for (_i65 = 0; _i65 < _size61; ++_i65)
+ uint32_t _size109;
+ ::apache::thrift::protocol::TType _etype112;
+ xfer += iprot->readListBegin(_etype112, _size109);
+ this->values.resize(_size109);
+ uint32_t _i113;
+ for (_i113 = 0; _i113 < _size109; ++_i113)
{
- xfer += iprot->readI32(this->values[_i65]);
+ xfer += iprot->readI32(this->values[_i113]);
}
xfer += iprot->readListEnd();
}
@@ -2334,15 +3149,16 @@ uint32_t TI32Column::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TI32Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TI32Column");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size()));
- std::vector<int32_t> ::const_iterator _iter66;
- for (_iter66 = this->values.begin(); _iter66 != this->values.end(); ++_iter66)
+ std::vector<int32_t> ::const_iterator _iter114;
+ for (_iter114 = this->values.begin(); _iter114 != this->values.end(); ++_iter114)
{
- xfer += oprot->writeI32((*_iter66));
+ xfer += oprot->writeI32((*_iter114));
}
xfer += oprot->writeListEnd();
}
@@ -2354,6 +3170,7 @@ uint32_t TI32Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2363,6 +3180,37 @@ void swap(TI32Column &a, TI32Column &b) {
swap(a.nulls, b.nulls);
}
+TI32Column::TI32Column(const TI32Column& other115) {
+ values = other115.values;
+ nulls = other115.nulls;
+}
+TI32Column& TI32Column::operator=(const TI32Column& other116) {
+ values = other116.values;
+ nulls = other116.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TI32Column& obj) {
+ using apache::thrift::to_string;
+ out << "TI32Column(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TI64Column::~TI64Column() throw() {
+}
+
+
+void TI64Column::__set_values(const std::vector<int64_t> & val) {
+ this->values = val;
+}
+
+void TI64Column::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TI64Column::ascii_fingerprint = "925353917FC0AF87976A2338011F5A31";
const uint8_t TI64Column::binary_fingerprint[16] = {0x92,0x53,0x53,0x91,0x7F,0xC0,0xAF,0x87,0x97,0x6A,0x23,0x38,0x01,0x1F,0x5A,0x31};
@@ -2392,14 +3240,14 @@ uint32_t TI64Column::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size67;
- ::apache::thrift::protocol::TType _etype70;
- xfer += iprot->readListBegin(_etype70, _size67);
- this->values.resize(_size67);
- uint32_t _i71;
- for (_i71 = 0; _i71 < _size67; ++_i71)
+ uint32_t _size117;
+ ::apache::thrift::protocol::TType _etype120;
+ xfer += iprot->readListBegin(_etype120, _size117);
+ this->values.resize(_size117);
+ uint32_t _i121;
+ for (_i121 = 0; _i121 < _size117; ++_i121)
{
- xfer += iprot->readI64(this->values[_i71]);
+ xfer += iprot->readI64(this->values[_i121]);
}
xfer += iprot->readListEnd();
}
@@ -2434,15 +3282,16 @@ uint32_t TI64Column::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TI64Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TI64Column");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->values.size()));
- std::vector<int64_t> ::const_iterator _iter72;
- for (_iter72 = this->values.begin(); _iter72 != this->values.end(); ++_iter72)
+ std::vector<int64_t> ::const_iterator _iter122;
+ for (_iter122 = this->values.begin(); _iter122 != this->values.end(); ++_iter122)
{
- xfer += oprot->writeI64((*_iter72));
+ xfer += oprot->writeI64((*_iter122));
}
xfer += oprot->writeListEnd();
}
@@ -2454,6 +3303,7 @@ uint32_t TI64Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2463,6 +3313,37 @@ void swap(TI64Column &a, TI64Column &b) {
swap(a.nulls, b.nulls);
}
+TI64Column::TI64Column(const TI64Column& other123) {
+ values = other123.values;
+ nulls = other123.nulls;
+}
+TI64Column& TI64Column::operator=(const TI64Column& other124) {
+ values = other124.values;
+ nulls = other124.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TI64Column& obj) {
+ using apache::thrift::to_string;
+ out << "TI64Column(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TDoubleColumn::~TDoubleColumn() throw() {
+}
+
+
+void TDoubleColumn::__set_values(const std::vector<double> & val) {
+ this->values = val;
+}
+
+void TDoubleColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TDoubleColumn::ascii_fingerprint = "8FF1C050A8D7FD247AEB23CD71539C09";
const uint8_t TDoubleColumn::binary_fingerprint[16] = {0x8F,0xF1,0xC0,0x50,0xA8,0xD7,0xFD,0x24,0x7A,0xEB,0x23,0xCD,0x71,0x53,0x9C,0x09};
@@ -2492,14 +3373,14 @@ uint32_t TDoubleColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size73;
- ::apache::thrift::protocol::TType _etype76;
- xfer += iprot->readListBegin(_etype76, _size73);
- this->values.resize(_size73);
- uint32_t _i77;
- for (_i77 = 0; _i77 < _size73; ++_i77)
+ uint32_t _size125;
+ ::apache::thrift::protocol::TType _etype128;
+ xfer += iprot->readListBegin(_etype128, _size125);
+ this->values.resize(_size125);
+ uint32_t _i129;
+ for (_i129 = 0; _i129 < _size125; ++_i129)
{
- xfer += iprot->readDouble(this->values[_i77]);
+ xfer += iprot->readDouble(this->values[_i129]);
}
xfer += iprot->readListEnd();
}
@@ -2534,15 +3415,16 @@ uint32_t TDoubleColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TDoubleColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TDoubleColumn");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_DOUBLE, static_cast<uint32_t>(this->values.size()));
- std::vector<double> ::const_iterator _iter78;
- for (_iter78 = this->values.begin(); _iter78 != this->values.end(); ++_iter78)
+ std::vector<double> ::const_iterator _iter130;
+ for (_iter130 = this->values.begin(); _iter130 != this->values.end(); ++_iter130)
{
- xfer += oprot->writeDouble((*_iter78));
+ xfer += oprot->writeDouble((*_iter130));
}
xfer += oprot->writeListEnd();
}
@@ -2554,6 +3436,7 @@ uint32_t TDoubleColumn::write(::apache::thrift::protocol::TProtocol* oprot) cons
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2563,6 +3446,37 @@ void swap(TDoubleColumn &a, TDoubleColumn &b) {
swap(a.nulls, b.nulls);
}
+TDoubleColumn::TDoubleColumn(const TDoubleColumn& other131) {
+ values = other131.values;
+ nulls = other131.nulls;
+}
+TDoubleColumn& TDoubleColumn::operator=(const TDoubleColumn& other132) {
+ values = other132.values;
+ nulls = other132.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj) {
+ using apache::thrift::to_string;
+ out << "TDoubleColumn(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TStringColumn::~TStringColumn() throw() {
+}
+
+
+void TStringColumn::__set_values(const std::vector<std::string> & val) {
+ this->values = val;
+}
+
+void TStringColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TStringColumn::ascii_fingerprint = "BE556BF7091B2DABBA1863D5E458B15F";
const uint8_t TStringColumn::binary_fingerprint[16] = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F};
@@ -2592,14 +3506,14 @@ uint32_t TStringColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size79;
- ::apache::thrift::protocol::TType _etype82;
- xfer += iprot->readListBegin(_etype82, _size79);
- this->values.resize(_size79);
- uint32_t _i83;
- for (_i83 = 0; _i83 < _size79; ++_i83)
+ uint32_t _size133;
+ ::apache::thrift::protocol::TType _etype136;
+ xfer += iprot->readListBegin(_etype136, _size133);
+ this->values.resize(_size133);
+ uint32_t _i137;
+ for (_i137 = 0; _i137 < _size133; ++_i137)
{
- xfer += iprot->readString(this->values[_i83]);
+ xfer += iprot->readString(this->values[_i137]);
}
xfer += iprot->readListEnd();
}
@@ -2634,15 +3548,16 @@ uint32_t TStringColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TStringColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TStringColumn");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
- std::vector<std::string> ::const_iterator _iter84;
- for (_iter84 = this->values.begin(); _iter84 != this->values.end(); ++_iter84)
+ std::vector<std::string> ::const_iterator _iter138;
+ for (_iter138 = this->values.begin(); _iter138 != this->values.end(); ++_iter138)
{
- xfer += oprot->writeString((*_iter84));
+ xfer += oprot->writeString((*_iter138));
}
xfer += oprot->writeListEnd();
}
@@ -2654,6 +3569,7 @@ uint32_t TStringColumn::write(::apache::thrift::protocol::TProtocol* oprot) cons
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2663,6 +3579,37 @@ void swap(TStringColumn &a, TStringColumn &b) {
swap(a.nulls, b.nulls);
}
+TStringColumn::TStringColumn(const TStringColumn& other139) {
+ values = other139.values;
+ nulls = other139.nulls;
+}
+TStringColumn& TStringColumn::operator=(const TStringColumn& other140) {
+ values = other140.values;
+ nulls = other140.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TStringColumn& obj) {
+ using apache::thrift::to_string;
+ out << "TStringColumn(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TBinaryColumn::~TBinaryColumn() throw() {
+}
+
+
+void TBinaryColumn::__set_values(const std::vector<std::string> & val) {
+ this->values = val;
+}
+
+void TBinaryColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
const char* TBinaryColumn::ascii_fingerprint = "BE556BF7091B2DABBA1863D5E458B15F";
const uint8_t TBinaryColumn::binary_fingerprint[16] = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F};
@@ -2692,14 +3639,14 @@ uint32_t TBinaryColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size85;
- ::apache::thrift::protocol::TType _etype88;
- xfer += iprot->readListBegin(_etype88, _size85);
- this->values.resize(_size85);
- uint32_t _i89;
- for (_i89 = 0; _i89 < _size85; ++_i89)
+ uint32_t _size141;
+ ::apache::thrift::protocol::TType _etype144;
+ xfer += iprot->readListBegin(_etype144, _size141);
+ this->values.resize(_size141);
+ uint32_t _i145;
+ for (_i145 = 0; _i145 < _size141; ++_i145)
{
- xfer += iprot->readBinary(this->values[_i89]);
+ xfer += iprot->readBinary(this->values[_i145]);
}
xfer += iprot->readListEnd();
}
@@ -2734,15 +3681,16 @@ uint32_t TBinaryColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TBinaryColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TBinaryColumn");
xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
- std::vector<std::string> ::const_iterator _iter90;
- for (_iter90 = this->values.begin(); _iter90 != this->values.end(); ++_iter90)
+ std::vector<std::string> ::const_iterator _iter146;
+ for (_iter146 = this->values.begin(); _iter146 != this->values.end(); ++_iter146)
{
- xfer += oprot->writeBinary((*_iter90));
+ xfer += oprot->writeBinary((*_iter146));
}
xfer += oprot->writeListEnd();
}
@@ -2754,6 +3702,7 @@ uint32_t TBinaryColumn::write(::apache::thrift::protocol::TProtocol* oprot) cons
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2763,6 +3712,61 @@ void swap(TBinaryColumn &a, TBinaryColumn &b) {
swap(a.nulls, b.nulls);
}
+TBinaryColumn::TBinaryColumn(const TBinaryColumn& other147) {
+ values = other147.values;
+ nulls = other147.nulls;
+}
+TBinaryColumn& TBinaryColumn::operator=(const TBinaryColumn& other148) {
+ values = other148.values;
+ nulls = other148.nulls;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj) {
+ using apache::thrift::to_string;
+ out << "TBinaryColumn(";
+ out << "values=" << to_string(obj.values);
+ out << ", " << "nulls=" << to_string(obj.nulls);
+ out << ")";
+ return out;
+}
+
+
+TColumn::~TColumn() throw() {
+}
+
+
+void TColumn::__set_boolVal(const TBoolColumn& val) {
+ this->boolVal = val;
+}
+
+void TColumn::__set_byteVal(const TByteColumn& val) {
+ this->byteVal = val;
+}
+
+void TColumn::__set_i16Val(const TI16Column& val) {
+ this->i16Val = val;
+}
+
+void TColumn::__set_i32Val(const TI32Column& val) {
+ this->i32Val = val;
+}
+
+void TColumn::__set_i64Val(const TI64Column& val) {
+ this->i64Val = val;
+}
+
+void TColumn::__set_doubleVal(const TDoubleColumn& val) {
+ this->doubleVal = val;
+}
+
+void TColumn::__set_stringVal(const TStringColumn& val) {
+ this->stringVal = val;
+}
+
+void TColumn::__set_binaryVal(const TBinaryColumn& val) {
+ this->binaryVal = val;
+}
+
const char* TColumn::ascii_fingerprint = "E6ADD10B4CDDE61A19E8878CC7039A17";
const uint8_t TColumn::binary_fingerprint[16] = {0xE6,0xAD,0xD1,0x0B,0x4C,0xDD,0xE6,0x1A,0x19,0xE8,0x87,0x8C,0xC7,0x03,0x9A,0x17};
@@ -2864,6 +3868,7 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TColumn");
xfer += oprot->writeFieldBegin("boolVal", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -2900,6 +3905,7 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -2916,6 +3922,62 @@ void swap(TColumn &a, TColumn &b) {
swap(a.__isset, b.__isset);
}
+TColumn::TColumn(const TColumn& other149) {
+ boolVal = other149.boolVal;
+ byteVal = other149.byteVal;
+ i16Val = other149.i16Val;
+ i32Val = other149.i32Val;
+ i64Val = other149.i64Val;
+ doubleVal = other149.doubleVal;
+ stringVal = other149.stringVal;
+ binaryVal = other149.binaryVal;
+ __isset = other149.__isset;
+}
+TColumn& TColumn::operator=(const TColumn& other150) {
+ boolVal = other150.boolVal;
+ byteVal = other150.byteVal;
+ i16Val = other150.i16Val;
+ i32Val = other150.i32Val;
+ i64Val = other150.i64Val;
+ doubleVal = other150.doubleVal;
+ stringVal = other150.stringVal;
+ binaryVal = other150.binaryVal;
+ __isset = other150.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TColumn& obj) {
+ using apache::thrift::to_string;
+ out << "TColumn(";
+ out << "boolVal=" << to_string(obj.boolVal);
+ out << ", " << "byteVal=" << to_string(obj.byteVal);
+ out << ", " << "i16Val=" << to_string(obj.i16Val);
+ out << ", " << "i32Val=" << to_string(obj.i32Val);
+ out << ", " << "i64Val=" << to_string(obj.i64Val);
+ out << ", " << "doubleVal=" << to_string(obj.doubleVal);
+ out << ", " << "stringVal=" << to_string(obj.stringVal);
+ out << ", " << "binaryVal=" << to_string(obj.binaryVal);
+ out << ")";
+ return out;
+}
+
+
+TRowSet::~TRowSet() throw() {
+}
+
+
+void TRowSet::__set_startRowOffset(const int64_t val) {
+ this->startRowOffset = val;
+}
+
+void TRowSet::__set_rows(const std::vector<TRow> & val) {
+ this->rows = val;
+}
+
+void TRowSet::__set_columns(const std::vector<TColumn> & val) {
+ this->columns = val;
+__isset.columns = true;
+}
+
const char* TRowSet::ascii_fingerprint = "46DA30A870489C7A58105AE0080DAEBF";
const uint8_t TRowSet::binary_fingerprint[16] = {0x46,0xDA,0x30,0xA8,0x70,0x48,0x9C,0x7A,0x58,0x10,0x5A,0xE0,0x08,0x0D,0xAE,0xBF};
@@ -2953,14 +4015,14 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->rows.clear();
- uint32_t _size91;
- ::apache::thrift::protocol::TType _etype94;
- xfer += iprot->readListBegin(_etype94, _size91);
- this->rows.resize(_size91);
- uint32_t _i95;
- for (_i95 = 0; _i95 < _size91; ++_i95)
+ uint32_t _size151;
+ ::apache::thrift::protocol::TType _etype154;
+ xfer += iprot->readListBegin(_etype154, _size151);
+ this->rows.resize(_size151);
+ uint32_t _i155;
+ for (_i155 = 0; _i155 < _size151; ++_i155)
{
- xfer += this->rows[_i95].read(iprot);
+ xfer += this->rows[_i155].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -2973,14 +4035,14 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->columns.clear();
- uint32_t _size96;
- ::apache::thrift::protocol::TType _etype99;
- xfer += iprot->readListBegin(_etype99, _size96);
- this->columns.resize(_size96);
- uint32_t _i100;
- for (_i100 = 0; _i100 < _size96; ++_i100)
+ uint32_t _size156;
+ ::apache::thrift::protocol::TType _etype159;
+ xfer += iprot->readListBegin(_etype159, _size156);
+ this->columns.resize(_size156);
+ uint32_t _i160;
+ for (_i160 = 0; _i160 < _size156; ++_i160)
{
- xfer += this->columns[_i100].read(iprot);
+ xfer += this->columns[_i160].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -3007,6 +4069,7 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TRowSet");
xfer += oprot->writeFieldBegin("startRowOffset", ::apache::thrift::protocol::T_I64, 1);
@@ -3016,10 +4079,10 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rows.size()));
- std::vector<TRow> ::const_iterator _iter101;
- for (_iter101 = this->rows.begin(); _iter101 != this->rows.end(); ++_iter101)
+ std::vector<TRow> ::const_iterator _iter161;
+ for (_iter161 = this->rows.begin(); _iter161 != this->rows.end(); ++_iter161)
{
- xfer += (*_iter101).write(oprot);
+ xfer += (*_iter161).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -3029,10 +4092,10 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
- std::vector<TColumn> ::const_iterator _iter102;
- for (_iter102 = this->columns.begin(); _iter102 != this->columns.end(); ++_iter102)
+ std::vector<TColumn> ::const_iterator _iter162;
+ for (_iter162 = this->columns.begin(); _iter162 != this->columns.end(); ++_iter162)
{
- xfer += (*_iter102).write(oprot);
+ xfer += (*_iter162).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -3040,6 +4103,7 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -3051,6 +4115,58 @@ void swap(TRowSet &a, TRowSet &b) {
swap(a.__isset, b.__isset);
}
+TRowSet::TRowSet(const TRowSet& other163) {
+ startRowOffset = other163.startRowOffset;
+ rows = other163.rows;
+ columns = other163.columns;
+ __isset = other163.__isset;
+}
+TRowSet& TRowSet::operator=(const TRowSet& other164) {
+ startRowOffset = other164.startRowOffset;
+ rows = other164.rows;
+ columns = other164.columns;
+ __isset = other164.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TRowSet& obj) {
+ using apache::thrift::to_string;
+ out << "TRowSet(";
+ out << "startRowOffset=" << to_string(obj.startRowOffset);
+ out << ", " << "rows=" << to_string(obj.rows);
+ out << ", " << "columns="; (obj.__isset.columns ? (out << to_string(obj.columns)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+TStatus::~TStatus() throw() {
+}
+
+
+void TStatus::__set_statusCode(const TStatusCode::type val) {
+ this->statusCode = val;
+}
+
+void TStatus::__set_infoMessages(const std::vector<std::string> & val) {
+ this->infoMessages = val;
+__isset.infoMessages = true;
+}
+
+void TStatus::__set_sqlState(const std::string& val) {
+ this->sqlState = val;
+__isset.sqlState = true;
+}
+
+void TStatus::__set_errorCode(const int32_t val) {
+ this->errorCode = val;
+__isset.errorCode = true;
+}
+
+void TStatus::__set_errorMessage(const std::string& val) {
+ this->errorMessage = val;
+__isset.errorMessage = true;
+}
+
const char* TStatus::ascii_fingerprint = "D5DEF49634A59C615C1B3A6F7D0DADB5";
const uint8_t TStatus::binary_fingerprint[16] = {0xD5,0xDE,0xF4,0x96,0x34,0xA5,0x9C,0x61,0x5C,0x1B,0x3A,0x6F,0x7D,0x0D,0xAD,0xB5};
@@ -3077,9 +4193,9 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast103;
- xfer += iprot->readI32(ecast103);
- this->statusCode = (TStatusCode::type)ecast103;
+ int32_t ecast165;
+ xfer += iprot->readI32(ecast165);
+ this->statusCode = (TStatusCode::type)ecast165;
isset_statusCode = true;
} else {
xfer += iprot->skip(ftype);
@@ -3089,14 +4205,14 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->infoMessages.clear();
- uint32_t _size104;
- ::apache::thrift::protocol::TType _etype107;
- xfer += iprot->readListBegin(_etype107, _size104);
- this->infoMessages.resize(_size104);
- uint32_t _i108;
- for (_i108 = 0; _i108 < _size104; ++_i108)
+ uint32_t _size166;
+ ::apache::thrift::protocol::TType _etype169;
+ xfer += iprot->readListBegin(_etype169, _size166);
+ this->infoMessages.resize(_size166);
+ uint32_t _i170;
+ for (_i170 = 0; _i170 < _size166; ++_i170)
{
- xfer += iprot->readString(this->infoMessages[_i108]);
+ xfer += iprot->readString(this->infoMessages[_i170]);
}
xfer += iprot->readListEnd();
}
@@ -3145,6 +4261,7 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
xfer += oprot->writeStructBegin("TStatus");
xfer += oprot->writeFieldBegin("statusCode", ::apache::thrift::protocol::T_I32, 1);
@@ -3155,10 +4272,10 @@ uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("infoMessages", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->infoMessages.size()));
- std::vector<std::string> ::const_iterator _iter109;
- for (_iter109 = this->infoMessages.begin(); _iter109 != this->infoMessages.end(); ++_iter109)
+ std::vector<std::string> ::const_iterator _iter171;
+ for (_iter171 = this->infoMessages.begin(); _iter171 != this->infoMessages.end(); ++_iter171)
{
- xfer += oprot->writeString((*_iter109));
+ xfer += oprot->writeString((*_iter171));
}
xfer += oprot->writeListEnd();
}
@@ -3181,6 +4298,7 @@ uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
}
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
return xfer;
}
@@ -3194,6 +4312,48 @@ void swap(TStatus &a, TStatus &b) {
swap(a.__isset, b.__isset);
}
+TStatus::TStatus(const TStatus& other172) {
+ statusCode = other172.statusCode;
+ infoMessages = other172.infoMessages;
+ sqlState = other172.sqlState;
+ errorCode = other172.errorCode;
+ errorMessage = other172.errorMessage;
+ __isset = other172.__isset;
+}
+TStatus& TStatus::operator=(const TStatus& other173) {
+ statusCode = other173.statusCode;
+ infoMessages = other173.infoMessages;
+ sqlState = other173.sqlState;
+ errorCode = other173.errorCode;
+ errorMessage = other173.errorMessage;
+ __isset = other173.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TStatus& obj) {
+ using apache::thrift::to_string;
+ out << "TStatus(";
+ out << "statusCode=" << to_string(obj.statusCode);
+ out << ", " << "infoMessages="; (obj.__isset.infoMessages ? (out << to_string(obj.infoMessages)) : (out << "<null>"));
+ out << ", " << "sqlState="; (obj.__isset.sqlState ? (out << to_string(obj.sqlState)) : (out << "<null>"));
+ out << ", " << "errorCode="; (obj.__isset.errorCode ? (out << to_string(obj.errorCode)) : (out << "<null>"));
+ out << ", " << "errorMessage="; (obj.__isset.errorMessage ? (out << to_string(obj.errorMessage)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+THandleIdentifier::~THandleIdentifier() throw() {
+}
+
+
+void THandleIdentifier::__set_guid(const std::string& val) {
+ this->guid = val;
+}
+
+void THandleIdentifier::__set_secret(const std::string& val) {
+ this->secret = val;
+}
+
const char* THandleIdentifier::ascii_fingerprint = "07A9615F837F7D0A952B595DD
<TRUNCATED>