You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by sp...@apache.org on 2018/05/05 12:42:54 UTC
[2/4] hive git commit: HIVE-19371: Add table ownerType to HMS thrift
API (Sergio Pena, reviewed by Sahil Takiar, Vihang Karajgaonkar)
http://git-wip-us.apache.org/repos/asf/hive/blob/a84fff8a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 25d851b..af975fc 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -6304,6 +6304,11 @@ void Table::__set_catName(const std::string& val) {
__isset.catName = true;
}
+void Table::__set_ownerType(const PrincipalType::type val) {
+ this->ownerType = val;
+__isset.ownerType = true;
+}
+
uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
@@ -6488,6 +6493,16 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) {
xfer += iprot->skip(ftype);
}
break;
+ case 18:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast246;
+ xfer += iprot->readI32(ecast246);
+ this->ownerType = (PrincipalType::type)ecast246;
+ this->__isset.ownerType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -6536,10 +6551,10 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionKeys.size()));
- std::vector<FieldSchema> ::const_iterator _iter246;
- for (_iter246 = this->partitionKeys.begin(); _iter246 != this->partitionKeys.end(); ++_iter246)
+ std::vector<FieldSchema> ::const_iterator _iter247;
+ for (_iter247 = this->partitionKeys.begin(); _iter247 != this->partitionKeys.end(); ++_iter247)
{
- xfer += (*_iter246).write(oprot);
+ xfer += (*_iter247).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6548,11 +6563,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 9);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter247;
- for (_iter247 = this->parameters.begin(); _iter247 != this->parameters.end(); ++_iter247)
+ std::map<std::string, std::string> ::const_iterator _iter248;
+ for (_iter248 = this->parameters.begin(); _iter248 != this->parameters.end(); ++_iter248)
{
- xfer += oprot->writeString(_iter247->first);
- xfer += oprot->writeString(_iter247->second);
+ xfer += oprot->writeString(_iter248->first);
+ xfer += oprot->writeString(_iter248->second);
}
xfer += oprot->writeMapEnd();
}
@@ -6595,6 +6610,11 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeString(this->catName);
xfer += oprot->writeFieldEnd();
}
+ if (this->__isset.ownerType) {
+ xfer += oprot->writeFieldBegin("ownerType", ::apache::thrift::protocol::T_I32, 18);
+ xfer += oprot->writeI32((int32_t)this->ownerType);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
@@ -6619,30 +6639,11 @@ void swap(Table &a, Table &b) {
swap(a.rewriteEnabled, b.rewriteEnabled);
swap(a.creationMetadata, b.creationMetadata);
swap(a.catName, b.catName);
+ swap(a.ownerType, b.ownerType);
swap(a.__isset, b.__isset);
}
-Table::Table(const Table& other248) {
- tableName = other248.tableName;
- dbName = other248.dbName;
- owner = other248.owner;
- createTime = other248.createTime;
- lastAccessTime = other248.lastAccessTime;
- retention = other248.retention;
- sd = other248.sd;
- partitionKeys = other248.partitionKeys;
- parameters = other248.parameters;
- viewOriginalText = other248.viewOriginalText;
- viewExpandedText = other248.viewExpandedText;
- tableType = other248.tableType;
- privileges = other248.privileges;
- temporary = other248.temporary;
- rewriteEnabled = other248.rewriteEnabled;
- creationMetadata = other248.creationMetadata;
- catName = other248.catName;
- __isset = other248.__isset;
-}
-Table& Table::operator=(const Table& other249) {
+Table::Table(const Table& other249) {
tableName = other249.tableName;
dbName = other249.dbName;
owner = other249.owner;
@@ -6660,7 +6661,29 @@ Table& Table::operator=(const Table& other249) {
rewriteEnabled = other249.rewriteEnabled;
creationMetadata = other249.creationMetadata;
catName = other249.catName;
+ ownerType = other249.ownerType;
__isset = other249.__isset;
+}
+Table& Table::operator=(const Table& other250) {
+ tableName = other250.tableName;
+ dbName = other250.dbName;
+ owner = other250.owner;
+ createTime = other250.createTime;
+ lastAccessTime = other250.lastAccessTime;
+ retention = other250.retention;
+ sd = other250.sd;
+ partitionKeys = other250.partitionKeys;
+ parameters = other250.parameters;
+ viewOriginalText = other250.viewOriginalText;
+ viewExpandedText = other250.viewExpandedText;
+ tableType = other250.tableType;
+ privileges = other250.privileges;
+ temporary = other250.temporary;
+ rewriteEnabled = other250.rewriteEnabled;
+ creationMetadata = other250.creationMetadata;
+ catName = other250.catName;
+ ownerType = other250.ownerType;
+ __isset = other250.__isset;
return *this;
}
void Table::printTo(std::ostream& out) const {
@@ -6683,6 +6706,7 @@ void Table::printTo(std::ostream& out) const {
out << ", " << "rewriteEnabled="; (__isset.rewriteEnabled ? (out << to_string(rewriteEnabled)) : (out << "<null>"));
out << ", " << "creationMetadata="; (__isset.creationMetadata ? (out << to_string(creationMetadata)) : (out << "<null>"));
out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>"));
+ out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "<null>"));
out << ")";
}
@@ -6754,14 +6778,14 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size250;
- ::apache::thrift::protocol::TType _etype253;
- xfer += iprot->readListBegin(_etype253, _size250);
- this->values.resize(_size250);
- uint32_t _i254;
- for (_i254 = 0; _i254 < _size250; ++_i254)
+ uint32_t _size251;
+ ::apache::thrift::protocol::TType _etype254;
+ xfer += iprot->readListBegin(_etype254, _size251);
+ this->values.resize(_size251);
+ uint32_t _i255;
+ for (_i255 = 0; _i255 < _size251; ++_i255)
{
- xfer += iprot->readString(this->values[_i254]);
+ xfer += iprot->readString(this->values[_i255]);
}
xfer += iprot->readListEnd();
}
@@ -6814,17 +6838,17 @@ uint32_t Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size255;
- ::apache::thrift::protocol::TType _ktype256;
- ::apache::thrift::protocol::TType _vtype257;
- xfer += iprot->readMapBegin(_ktype256, _vtype257, _size255);
- uint32_t _i259;
- for (_i259 = 0; _i259 < _size255; ++_i259)
+ uint32_t _size256;
+ ::apache::thrift::protocol::TType _ktype257;
+ ::apache::thrift::protocol::TType _vtype258;
+ xfer += iprot->readMapBegin(_ktype257, _vtype258, _size256);
+ uint32_t _i260;
+ for (_i260 = 0; _i260 < _size256; ++_i260)
{
- std::string _key260;
- xfer += iprot->readString(_key260);
- std::string& _val261 = this->parameters[_key260];
- xfer += iprot->readString(_val261);
+ std::string _key261;
+ xfer += iprot->readString(_key261);
+ std::string& _val262 = this->parameters[_key261];
+ xfer += iprot->readString(_val262);
}
xfer += iprot->readMapEnd();
}
@@ -6869,10 +6893,10 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
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 _iter262;
- for (_iter262 = this->values.begin(); _iter262 != this->values.end(); ++_iter262)
+ std::vector<std::string> ::const_iterator _iter263;
+ for (_iter263 = this->values.begin(); _iter263 != this->values.end(); ++_iter263)
{
- xfer += oprot->writeString((*_iter262));
+ xfer += oprot->writeString((*_iter263));
}
xfer += oprot->writeListEnd();
}
@@ -6901,11 +6925,11 @@ uint32_t Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 7);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter263;
- for (_iter263 = this->parameters.begin(); _iter263 != this->parameters.end(); ++_iter263)
+ std::map<std::string, std::string> ::const_iterator _iter264;
+ for (_iter264 = this->parameters.begin(); _iter264 != this->parameters.end(); ++_iter264)
{
- xfer += oprot->writeString(_iter263->first);
- xfer += oprot->writeString(_iter263->second);
+ xfer += oprot->writeString(_iter264->first);
+ xfer += oprot->writeString(_iter264->second);
}
xfer += oprot->writeMapEnd();
}
@@ -6940,19 +6964,7 @@ void swap(Partition &a, Partition &b) {
swap(a.__isset, b.__isset);
}
-Partition::Partition(const Partition& other264) {
- values = other264.values;
- dbName = other264.dbName;
- tableName = other264.tableName;
- createTime = other264.createTime;
- lastAccessTime = other264.lastAccessTime;
- sd = other264.sd;
- parameters = other264.parameters;
- privileges = other264.privileges;
- catName = other264.catName;
- __isset = other264.__isset;
-}
-Partition& Partition::operator=(const Partition& other265) {
+Partition::Partition(const Partition& other265) {
values = other265.values;
dbName = other265.dbName;
tableName = other265.tableName;
@@ -6963,6 +6975,18 @@ Partition& Partition::operator=(const Partition& other265) {
privileges = other265.privileges;
catName = other265.catName;
__isset = other265.__isset;
+}
+Partition& Partition::operator=(const Partition& other266) {
+ values = other266.values;
+ dbName = other266.dbName;
+ tableName = other266.tableName;
+ createTime = other266.createTime;
+ lastAccessTime = other266.lastAccessTime;
+ sd = other266.sd;
+ parameters = other266.parameters;
+ privileges = other266.privileges;
+ catName = other266.catName;
+ __isset = other266.__isset;
return *this;
}
void Partition::printTo(std::ostream& out) const {
@@ -7035,14 +7059,14 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->values.clear();
- uint32_t _size266;
- ::apache::thrift::protocol::TType _etype269;
- xfer += iprot->readListBegin(_etype269, _size266);
- this->values.resize(_size266);
- uint32_t _i270;
- for (_i270 = 0; _i270 < _size266; ++_i270)
+ uint32_t _size267;
+ ::apache::thrift::protocol::TType _etype270;
+ xfer += iprot->readListBegin(_etype270, _size267);
+ this->values.resize(_size267);
+ uint32_t _i271;
+ for (_i271 = 0; _i271 < _size267; ++_i271)
{
- xfer += iprot->readString(this->values[_i270]);
+ xfer += iprot->readString(this->values[_i271]);
}
xfer += iprot->readListEnd();
}
@@ -7079,17 +7103,17 @@ uint32_t PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->parameters.clear();
- uint32_t _size271;
- ::apache::thrift::protocol::TType _ktype272;
- ::apache::thrift::protocol::TType _vtype273;
- xfer += iprot->readMapBegin(_ktype272, _vtype273, _size271);
- uint32_t _i275;
- for (_i275 = 0; _i275 < _size271; ++_i275)
+ uint32_t _size272;
+ ::apache::thrift::protocol::TType _ktype273;
+ ::apache::thrift::protocol::TType _vtype274;
+ xfer += iprot->readMapBegin(_ktype273, _vtype274, _size272);
+ uint32_t _i276;
+ for (_i276 = 0; _i276 < _size272; ++_i276)
{
- std::string _key276;
- xfer += iprot->readString(_key276);
- std::string& _val277 = this->parameters[_key276];
- xfer += iprot->readString(_val277);
+ std::string _key277;
+ xfer += iprot->readString(_key277);
+ std::string& _val278 = this->parameters[_key277];
+ xfer += iprot->readString(_val278);
}
xfer += iprot->readMapEnd();
}
@@ -7126,10 +7150,10 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
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 _iter278;
- for (_iter278 = this->values.begin(); _iter278 != this->values.end(); ++_iter278)
+ std::vector<std::string> ::const_iterator _iter279;
+ for (_iter279 = this->values.begin(); _iter279 != this->values.end(); ++_iter279)
{
- xfer += oprot->writeString((*_iter278));
+ xfer += oprot->writeString((*_iter279));
}
xfer += oprot->writeListEnd();
}
@@ -7150,11 +7174,11 @@ uint32_t PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
- std::map<std::string, std::string> ::const_iterator _iter279;
- for (_iter279 = this->parameters.begin(); _iter279 != this->parameters.end(); ++_iter279)
+ std::map<std::string, std::string> ::const_iterator _iter280;
+ for (_iter280 = this->parameters.begin(); _iter280 != this->parameters.end(); ++_iter280)
{
- xfer += oprot->writeString(_iter279->first);
- xfer += oprot->writeString(_iter279->second);
+ xfer += oprot->writeString(_iter280->first);
+ xfer += oprot->writeString(_iter280->second);
}
xfer += oprot->writeMapEnd();
}
@@ -7181,16 +7205,7 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) {
swap(a.__isset, b.__isset);
}
-PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other280) {
- values = other280.values;
- createTime = other280.createTime;
- lastAccessTime = other280.lastAccessTime;
- relativePath = other280.relativePath;
- parameters = other280.parameters;
- privileges = other280.privileges;
- __isset = other280.__isset;
-}
-PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other281) {
+PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other281) {
values = other281.values;
createTime = other281.createTime;
lastAccessTime = other281.lastAccessTime;
@@ -7198,6 +7213,15 @@ PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& othe
parameters = other281.parameters;
privileges = other281.privileges;
__isset = other281.__isset;
+}
+PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& other282) {
+ values = other282.values;
+ createTime = other282.createTime;
+ lastAccessTime = other282.lastAccessTime;
+ relativePath = other282.relativePath;
+ parameters = other282.parameters;
+ privileges = other282.privileges;
+ __isset = other282.__isset;
return *this;
}
void PartitionWithoutSD::printTo(std::ostream& out) const {
@@ -7250,14 +7274,14 @@ uint32_t PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size282;
- ::apache::thrift::protocol::TType _etype285;
- xfer += iprot->readListBegin(_etype285, _size282);
- this->partitions.resize(_size282);
- uint32_t _i286;
- for (_i286 = 0; _i286 < _size282; ++_i286)
+ uint32_t _size283;
+ ::apache::thrift::protocol::TType _etype286;
+ xfer += iprot->readListBegin(_etype286, _size283);
+ this->partitions.resize(_size283);
+ uint32_t _i287;
+ for (_i287 = 0; _i287 < _size283; ++_i287)
{
- xfer += this->partitions[_i286].read(iprot);
+ xfer += this->partitions[_i287].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7294,10 +7318,10 @@ uint32_t PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<PartitionWithoutSD> ::const_iterator _iter287;
- for (_iter287 = this->partitions.begin(); _iter287 != this->partitions.end(); ++_iter287)
+ std::vector<PartitionWithoutSD> ::const_iterator _iter288;
+ for (_iter288 = this->partitions.begin(); _iter288 != this->partitions.end(); ++_iter288)
{
- xfer += (*_iter287).write(oprot);
+ xfer += (*_iter288).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7319,15 +7343,15 @@ void swap(PartitionSpecWithSharedSD &a, PartitionSpecWithSharedSD &b) {
swap(a.__isset, b.__isset);
}
-PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other288) {
- partitions = other288.partitions;
- sd = other288.sd;
- __isset = other288.__isset;
-}
-PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other289) {
+PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const PartitionSpecWithSharedSD& other289) {
partitions = other289.partitions;
sd = other289.sd;
__isset = other289.__isset;
+}
+PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const PartitionSpecWithSharedSD& other290) {
+ partitions = other290.partitions;
+ sd = other290.sd;
+ __isset = other290.__isset;
return *this;
}
void PartitionSpecWithSharedSD::printTo(std::ostream& out) const {
@@ -7372,14 +7396,14 @@ uint32_t PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size290;
- ::apache::thrift::protocol::TType _etype293;
- xfer += iprot->readListBegin(_etype293, _size290);
- this->partitions.resize(_size290);
- uint32_t _i294;
- for (_i294 = 0; _i294 < _size290; ++_i294)
+ uint32_t _size291;
+ ::apache::thrift::protocol::TType _etype294;
+ xfer += iprot->readListBegin(_etype294, _size291);
+ this->partitions.resize(_size291);
+ uint32_t _i295;
+ for (_i295 = 0; _i295 < _size291; ++_i295)
{
- xfer += this->partitions[_i294].read(iprot);
+ xfer += this->partitions[_i295].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7408,10 +7432,10 @@ uint32_t PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter295;
- for (_iter295 = this->partitions.begin(); _iter295 != this->partitions.end(); ++_iter295)
+ std::vector<Partition> ::const_iterator _iter296;
+ for (_iter296 = this->partitions.begin(); _iter296 != this->partitions.end(); ++_iter296)
{
- xfer += (*_iter295).write(oprot);
+ xfer += (*_iter296).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7428,13 +7452,13 @@ void swap(PartitionListComposingSpec &a, PartitionListComposingSpec &b) {
swap(a.__isset, b.__isset);
}
-PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other296) {
- partitions = other296.partitions;
- __isset = other296.__isset;
-}
-PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other297) {
+PartitionListComposingSpec::PartitionListComposingSpec(const PartitionListComposingSpec& other297) {
partitions = other297.partitions;
__isset = other297.__isset;
+}
+PartitionListComposingSpec& PartitionListComposingSpec::operator=(const PartitionListComposingSpec& other298) {
+ partitions = other298.partitions;
+ __isset = other298.__isset;
return *this;
}
void PartitionListComposingSpec::printTo(std::ostream& out) const {
@@ -7605,16 +7629,7 @@ void swap(PartitionSpec &a, PartitionSpec &b) {
swap(a.__isset, b.__isset);
}
-PartitionSpec::PartitionSpec(const PartitionSpec& other298) {
- dbName = other298.dbName;
- tableName = other298.tableName;
- rootPath = other298.rootPath;
- sharedSDPartitionSpec = other298.sharedSDPartitionSpec;
- partitionList = other298.partitionList;
- catName = other298.catName;
- __isset = other298.__isset;
-}
-PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other299) {
+PartitionSpec::PartitionSpec(const PartitionSpec& other299) {
dbName = other299.dbName;
tableName = other299.tableName;
rootPath = other299.rootPath;
@@ -7622,6 +7637,15 @@ PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other299) {
partitionList = other299.partitionList;
catName = other299.catName;
__isset = other299.__isset;
+}
+PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other300) {
+ dbName = other300.dbName;
+ tableName = other300.tableName;
+ rootPath = other300.rootPath;
+ sharedSDPartitionSpec = other300.sharedSDPartitionSpec;
+ partitionList = other300.partitionList;
+ catName = other300.catName;
+ __isset = other300.__isset;
return *this;
}
void PartitionSpec::printTo(std::ostream& out) const {
@@ -7768,19 +7792,19 @@ void swap(BooleanColumnStatsData &a, BooleanColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other300) {
- numTrues = other300.numTrues;
- numFalses = other300.numFalses;
- numNulls = other300.numNulls;
- bitVectors = other300.bitVectors;
- __isset = other300.__isset;
-}
-BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other301) {
+BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& other301) {
numTrues = other301.numTrues;
numFalses = other301.numFalses;
numNulls = other301.numNulls;
bitVectors = other301.bitVectors;
__isset = other301.__isset;
+}
+BooleanColumnStatsData& BooleanColumnStatsData::operator=(const BooleanColumnStatsData& other302) {
+ numTrues = other302.numTrues;
+ numFalses = other302.numFalses;
+ numNulls = other302.numNulls;
+ bitVectors = other302.bitVectors;
+ __isset = other302.__isset;
return *this;
}
void BooleanColumnStatsData::printTo(std::ostream& out) const {
@@ -7943,21 +7967,21 @@ void swap(DoubleColumnStatsData &a, DoubleColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other302) {
- lowValue = other302.lowValue;
- highValue = other302.highValue;
- numNulls = other302.numNulls;
- numDVs = other302.numDVs;
- bitVectors = other302.bitVectors;
- __isset = other302.__isset;
-}
-DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other303) {
+DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& other303) {
lowValue = other303.lowValue;
highValue = other303.highValue;
numNulls = other303.numNulls;
numDVs = other303.numDVs;
bitVectors = other303.bitVectors;
__isset = other303.__isset;
+}
+DoubleColumnStatsData& DoubleColumnStatsData::operator=(const DoubleColumnStatsData& other304) {
+ lowValue = other304.lowValue;
+ highValue = other304.highValue;
+ numNulls = other304.numNulls;
+ numDVs = other304.numDVs;
+ bitVectors = other304.bitVectors;
+ __isset = other304.__isset;
return *this;
}
void DoubleColumnStatsData::printTo(std::ostream& out) const {
@@ -8121,21 +8145,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other304) {
- lowValue = other304.lowValue;
- highValue = other304.highValue;
- numNulls = other304.numNulls;
- numDVs = other304.numDVs;
- bitVectors = other304.bitVectors;
- __isset = other304.__isset;
-}
-LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other305) {
+LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other305) {
lowValue = other305.lowValue;
highValue = other305.highValue;
numNulls = other305.numNulls;
numDVs = other305.numDVs;
bitVectors = other305.bitVectors;
__isset = other305.__isset;
+}
+LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& other306) {
+ lowValue = other306.lowValue;
+ highValue = other306.highValue;
+ numNulls = other306.numNulls;
+ numDVs = other306.numDVs;
+ bitVectors = other306.bitVectors;
+ __isset = other306.__isset;
return *this;
}
void LongColumnStatsData::printTo(std::ostream& out) const {
@@ -8301,21 +8325,21 @@ void swap(StringColumnStatsData &a, StringColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other306) {
- maxColLen = other306.maxColLen;
- avgColLen = other306.avgColLen;
- numNulls = other306.numNulls;
- numDVs = other306.numDVs;
- bitVectors = other306.bitVectors;
- __isset = other306.__isset;
-}
-StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other307) {
+StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& other307) {
maxColLen = other307.maxColLen;
avgColLen = other307.avgColLen;
numNulls = other307.numNulls;
numDVs = other307.numDVs;
bitVectors = other307.bitVectors;
__isset = other307.__isset;
+}
+StringColumnStatsData& StringColumnStatsData::operator=(const StringColumnStatsData& other308) {
+ maxColLen = other308.maxColLen;
+ avgColLen = other308.avgColLen;
+ numNulls = other308.numNulls;
+ numDVs = other308.numDVs;
+ bitVectors = other308.bitVectors;
+ __isset = other308.__isset;
return *this;
}
void StringColumnStatsData::printTo(std::ostream& out) const {
@@ -8461,19 +8485,19 @@ void swap(BinaryColumnStatsData &a, BinaryColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other308) {
- maxColLen = other308.maxColLen;
- avgColLen = other308.avgColLen;
- numNulls = other308.numNulls;
- bitVectors = other308.bitVectors;
- __isset = other308.__isset;
-}
-BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other309) {
+BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& other309) {
maxColLen = other309.maxColLen;
avgColLen = other309.avgColLen;
numNulls = other309.numNulls;
bitVectors = other309.bitVectors;
__isset = other309.__isset;
+}
+BinaryColumnStatsData& BinaryColumnStatsData::operator=(const BinaryColumnStatsData& other310) {
+ maxColLen = other310.maxColLen;
+ avgColLen = other310.avgColLen;
+ numNulls = other310.numNulls;
+ bitVectors = other310.bitVectors;
+ __isset = other310.__isset;
return *this;
}
void BinaryColumnStatsData::printTo(std::ostream& out) const {
@@ -8578,13 +8602,13 @@ void swap(Decimal &a, Decimal &b) {
swap(a.unscaled, b.unscaled);
}
-Decimal::Decimal(const Decimal& other310) {
- scale = other310.scale;
- unscaled = other310.unscaled;
-}
-Decimal& Decimal::operator=(const Decimal& other311) {
+Decimal::Decimal(const Decimal& other311) {
scale = other311.scale;
unscaled = other311.unscaled;
+}
+Decimal& Decimal::operator=(const Decimal& other312) {
+ scale = other312.scale;
+ unscaled = other312.unscaled;
return *this;
}
void Decimal::printTo(std::ostream& out) const {
@@ -8745,21 +8769,21 @@ void swap(DecimalColumnStatsData &a, DecimalColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other312) {
- lowValue = other312.lowValue;
- highValue = other312.highValue;
- numNulls = other312.numNulls;
- numDVs = other312.numDVs;
- bitVectors = other312.bitVectors;
- __isset = other312.__isset;
-}
-DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other313) {
+DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& other313) {
lowValue = other313.lowValue;
highValue = other313.highValue;
numNulls = other313.numNulls;
numDVs = other313.numDVs;
bitVectors = other313.bitVectors;
__isset = other313.__isset;
+}
+DecimalColumnStatsData& DecimalColumnStatsData::operator=(const DecimalColumnStatsData& other314) {
+ lowValue = other314.lowValue;
+ highValue = other314.highValue;
+ numNulls = other314.numNulls;
+ numDVs = other314.numDVs;
+ bitVectors = other314.bitVectors;
+ __isset = other314.__isset;
return *this;
}
void DecimalColumnStatsData::printTo(std::ostream& out) const {
@@ -8845,11 +8869,11 @@ void swap(Date &a, Date &b) {
swap(a.daysSinceEpoch, b.daysSinceEpoch);
}
-Date::Date(const Date& other314) {
- daysSinceEpoch = other314.daysSinceEpoch;
-}
-Date& Date::operator=(const Date& other315) {
+Date::Date(const Date& other315) {
daysSinceEpoch = other315.daysSinceEpoch;
+}
+Date& Date::operator=(const Date& other316) {
+ daysSinceEpoch = other316.daysSinceEpoch;
return *this;
}
void Date::printTo(std::ostream& out) const {
@@ -9009,21 +9033,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData &b) {
swap(a.__isset, b.__isset);
}
-DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other316) {
- lowValue = other316.lowValue;
- highValue = other316.highValue;
- numNulls = other316.numNulls;
- numDVs = other316.numDVs;
- bitVectors = other316.bitVectors;
- __isset = other316.__isset;
-}
-DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other317) {
+DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other317) {
lowValue = other317.lowValue;
highValue = other317.highValue;
numNulls = other317.numNulls;
numDVs = other317.numDVs;
bitVectors = other317.bitVectors;
__isset = other317.__isset;
+}
+DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& other318) {
+ lowValue = other318.lowValue;
+ highValue = other318.highValue;
+ numNulls = other318.numNulls;
+ numDVs = other318.numDVs;
+ bitVectors = other318.bitVectors;
+ __isset = other318.__isset;
return *this;
}
void DateColumnStatsData::printTo(std::ostream& out) const {
@@ -9209,17 +9233,7 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData &b) {
swap(a.__isset, b.__isset);
}
-ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other318) {
- booleanStats = other318.booleanStats;
- longStats = other318.longStats;
- doubleStats = other318.doubleStats;
- stringStats = other318.stringStats;
- binaryStats = other318.binaryStats;
- decimalStats = other318.decimalStats;
- dateStats = other318.dateStats;
- __isset = other318.__isset;
-}
-ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other319) {
+ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& other319) {
booleanStats = other319.booleanStats;
longStats = other319.longStats;
doubleStats = other319.doubleStats;
@@ -9228,6 +9242,16 @@ ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData
decimalStats = other319.decimalStats;
dateStats = other319.dateStats;
__isset = other319.__isset;
+}
+ColumnStatisticsData& ColumnStatisticsData::operator=(const ColumnStatisticsData& other320) {
+ booleanStats = other320.booleanStats;
+ longStats = other320.longStats;
+ doubleStats = other320.doubleStats;
+ stringStats = other320.stringStats;
+ binaryStats = other320.binaryStats;
+ decimalStats = other320.decimalStats;
+ dateStats = other320.dateStats;
+ __isset = other320.__isset;
return *this;
}
void ColumnStatisticsData::printTo(std::ostream& out) const {
@@ -9355,15 +9379,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj &b) {
swap(a.statsData, b.statsData);
}
-ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other320) {
- colName = other320.colName;
- colType = other320.colType;
- statsData = other320.statsData;
-}
-ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other321) {
+ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other321) {
colName = other321.colName;
colType = other321.colType;
statsData = other321.statsData;
+}
+ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& other322) {
+ colName = other322.colName;
+ colType = other322.colType;
+ statsData = other322.statsData;
return *this;
}
void ColumnStatisticsObj::printTo(std::ostream& out) const {
@@ -9545,16 +9569,7 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc &b) {
swap(a.__isset, b.__isset);
}
-ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other322) {
- isTblLevel = other322.isTblLevel;
- dbName = other322.dbName;
- tableName = other322.tableName;
- partName = other322.partName;
- lastAnalyzed = other322.lastAnalyzed;
- catName = other322.catName;
- __isset = other322.__isset;
-}
-ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other323) {
+ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& other323) {
isTblLevel = other323.isTblLevel;
dbName = other323.dbName;
tableName = other323.tableName;
@@ -9562,6 +9577,15 @@ ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc
lastAnalyzed = other323.lastAnalyzed;
catName = other323.catName;
__isset = other323.__isset;
+}
+ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const ColumnStatisticsDesc& other324) {
+ isTblLevel = other324.isTblLevel;
+ dbName = other324.dbName;
+ tableName = other324.tableName;
+ partName = other324.partName;
+ lastAnalyzed = other324.lastAnalyzed;
+ catName = other324.catName;
+ __isset = other324.__isset;
return *this;
}
void ColumnStatisticsDesc::printTo(std::ostream& out) const {
@@ -9624,14 +9648,14 @@ uint32_t ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->statsObj.clear();
- uint32_t _size324;
- ::apache::thrift::protocol::TType _etype327;
- xfer += iprot->readListBegin(_etype327, _size324);
- this->statsObj.resize(_size324);
- uint32_t _i328;
- for (_i328 = 0; _i328 < _size324; ++_i328)
+ uint32_t _size325;
+ ::apache::thrift::protocol::TType _etype328;
+ xfer += iprot->readListBegin(_etype328, _size325);
+ this->statsObj.resize(_size325);
+ uint32_t _i329;
+ for (_i329 = 0; _i329 < _size325; ++_i329)
{
- xfer += this->statsObj[_i328].read(iprot);
+ xfer += this->statsObj[_i329].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9668,10 +9692,10 @@ uint32_t ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("statsObj", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->statsObj.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter329;
- for (_iter329 = this->statsObj.begin(); _iter329 != this->statsObj.end(); ++_iter329)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter330;
+ for (_iter330 = this->statsObj.begin(); _iter330 != this->statsObj.end(); ++_iter330)
{
- xfer += (*_iter329).write(oprot);
+ xfer += (*_iter330).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9688,13 +9712,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) {
swap(a.statsObj, b.statsObj);
}
-ColumnStatistics::ColumnStatistics(const ColumnStatistics& other330) {
- statsDesc = other330.statsDesc;
- statsObj = other330.statsObj;
-}
-ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other331) {
+ColumnStatistics::ColumnStatistics(const ColumnStatistics& other331) {
statsDesc = other331.statsDesc;
statsObj = other331.statsObj;
+}
+ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& other332) {
+ statsDesc = other332.statsDesc;
+ statsObj = other332.statsObj;
return *this;
}
void ColumnStatistics::printTo(std::ostream& out) const {
@@ -9745,14 +9769,14 @@ uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size332;
- ::apache::thrift::protocol::TType _etype335;
- xfer += iprot->readListBegin(_etype335, _size332);
- this->colStats.resize(_size332);
- uint32_t _i336;
- for (_i336 = 0; _i336 < _size332; ++_i336)
+ uint32_t _size333;
+ ::apache::thrift::protocol::TType _etype336;
+ xfer += iprot->readListBegin(_etype336, _size333);
+ this->colStats.resize(_size333);
+ uint32_t _i337;
+ for (_i337 = 0; _i337 < _size333; ++_i337)
{
- xfer += this->colStats[_i336].read(iprot);
+ xfer += this->colStats[_i337].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9793,10 +9817,10 @@ uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter337;
- for (_iter337 = this->colStats.begin(); _iter337 != this->colStats.end(); ++_iter337)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter338;
+ for (_iter338 = this->colStats.begin(); _iter338 != this->colStats.end(); ++_iter338)
{
- xfer += (*_iter337).write(oprot);
+ xfer += (*_iter338).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9817,13 +9841,13 @@ void swap(AggrStats &a, AggrStats &b) {
swap(a.partsFound, b.partsFound);
}
-AggrStats::AggrStats(const AggrStats& other338) {
- colStats = other338.colStats;
- partsFound = other338.partsFound;
-}
-AggrStats& AggrStats::operator=(const AggrStats& other339) {
+AggrStats::AggrStats(const AggrStats& other339) {
colStats = other339.colStats;
partsFound = other339.partsFound;
+}
+AggrStats& AggrStats::operator=(const AggrStats& other340) {
+ colStats = other340.colStats;
+ partsFound = other340.partsFound;
return *this;
}
void AggrStats::printTo(std::ostream& out) const {
@@ -9874,14 +9898,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colStats.clear();
- uint32_t _size340;
- ::apache::thrift::protocol::TType _etype343;
- xfer += iprot->readListBegin(_etype343, _size340);
- this->colStats.resize(_size340);
- uint32_t _i344;
- for (_i344 = 0; _i344 < _size340; ++_i344)
+ uint32_t _size341;
+ ::apache::thrift::protocol::TType _etype344;
+ xfer += iprot->readListBegin(_etype344, _size341);
+ this->colStats.resize(_size341);
+ uint32_t _i345;
+ for (_i345 = 0; _i345 < _size341; ++_i345)
{
- xfer += this->colStats[_i344].read(iprot);
+ xfer += this->colStats[_i345].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9920,10 +9944,10 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size()));
- std::vector<ColumnStatistics> ::const_iterator _iter345;
- for (_iter345 = this->colStats.begin(); _iter345 != this->colStats.end(); ++_iter345)
+ std::vector<ColumnStatistics> ::const_iterator _iter346;
+ for (_iter346 = this->colStats.begin(); _iter346 != this->colStats.end(); ++_iter346)
{
- xfer += (*_iter345).write(oprot);
+ xfer += (*_iter346).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9946,15 +9970,15 @@ void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) {
swap(a.__isset, b.__isset);
}
-SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other346) {
- colStats = other346.colStats;
- needMerge = other346.needMerge;
- __isset = other346.__isset;
-}
-SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other347) {
+SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other347) {
colStats = other347.colStats;
needMerge = other347.needMerge;
__isset = other347.__isset;
+}
+SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other348) {
+ colStats = other348.colStats;
+ needMerge = other348.needMerge;
+ __isset = other348.__isset;
return *this;
}
void SetPartitionsStatsRequest::printTo(std::ostream& out) const {
@@ -10003,14 +10027,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fieldSchemas.clear();
- uint32_t _size348;
- ::apache::thrift::protocol::TType _etype351;
- xfer += iprot->readListBegin(_etype351, _size348);
- this->fieldSchemas.resize(_size348);
- uint32_t _i352;
- for (_i352 = 0; _i352 < _size348; ++_i352)
+ uint32_t _size349;
+ ::apache::thrift::protocol::TType _etype352;
+ xfer += iprot->readListBegin(_etype352, _size349);
+ this->fieldSchemas.resize(_size349);
+ uint32_t _i353;
+ for (_i353 = 0; _i353 < _size349; ++_i353)
{
- xfer += this->fieldSchemas[_i352].read(iprot);
+ xfer += this->fieldSchemas[_i353].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10023,17 +10047,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size353;
- ::apache::thrift::protocol::TType _ktype354;
- ::apache::thrift::protocol::TType _vtype355;
- xfer += iprot->readMapBegin(_ktype354, _vtype355, _size353);
- uint32_t _i357;
- for (_i357 = 0; _i357 < _size353; ++_i357)
+ uint32_t _size354;
+ ::apache::thrift::protocol::TType _ktype355;
+ ::apache::thrift::protocol::TType _vtype356;
+ xfer += iprot->readMapBegin(_ktype355, _vtype356, _size354);
+ uint32_t _i358;
+ for (_i358 = 0; _i358 < _size354; ++_i358)
{
- std::string _key358;
- xfer += iprot->readString(_key358);
- std::string& _val359 = this->properties[_key358];
- xfer += iprot->readString(_val359);
+ std::string _key359;
+ xfer += iprot->readString(_key359);
+ std::string& _val360 = this->properties[_key359];
+ xfer += iprot->readString(_val360);
}
xfer += iprot->readMapEnd();
}
@@ -10062,10 +10086,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fieldSchemas.size()));
- std::vector<FieldSchema> ::const_iterator _iter360;
- for (_iter360 = this->fieldSchemas.begin(); _iter360 != this->fieldSchemas.end(); ++_iter360)
+ std::vector<FieldSchema> ::const_iterator _iter361;
+ for (_iter361 = this->fieldSchemas.begin(); _iter361 != this->fieldSchemas.end(); ++_iter361)
{
- xfer += (*_iter360).write(oprot);
+ xfer += (*_iter361).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10074,11 +10098,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter361;
- for (_iter361 = this->properties.begin(); _iter361 != this->properties.end(); ++_iter361)
+ std::map<std::string, std::string> ::const_iterator _iter362;
+ for (_iter362 = this->properties.begin(); _iter362 != this->properties.end(); ++_iter362)
{
- xfer += oprot->writeString(_iter361->first);
- xfer += oprot->writeString(_iter361->second);
+ xfer += oprot->writeString(_iter362->first);
+ xfer += oprot->writeString(_iter362->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10096,15 +10120,15 @@ void swap(Schema &a, Schema &b) {
swap(a.__isset, b.__isset);
}
-Schema::Schema(const Schema& other362) {
- fieldSchemas = other362.fieldSchemas;
- properties = other362.properties;
- __isset = other362.__isset;
-}
-Schema& Schema::operator=(const Schema& other363) {
+Schema::Schema(const Schema& other363) {
fieldSchemas = other363.fieldSchemas;
properties = other363.properties;
__isset = other363.__isset;
+}
+Schema& Schema::operator=(const Schema& other364) {
+ fieldSchemas = other364.fieldSchemas;
+ properties = other364.properties;
+ __isset = other364.__isset;
return *this;
}
void Schema::printTo(std::ostream& out) const {
@@ -10149,17 +10173,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size364;
- ::apache::thrift::protocol::TType _ktype365;
- ::apache::thrift::protocol::TType _vtype366;
- xfer += iprot->readMapBegin(_ktype365, _vtype366, _size364);
- uint32_t _i368;
- for (_i368 = 0; _i368 < _size364; ++_i368)
+ uint32_t _size365;
+ ::apache::thrift::protocol::TType _ktype366;
+ ::apache::thrift::protocol::TType _vtype367;
+ xfer += iprot->readMapBegin(_ktype366, _vtype367, _size365);
+ uint32_t _i369;
+ for (_i369 = 0; _i369 < _size365; ++_i369)
{
- std::string _key369;
- xfer += iprot->readString(_key369);
- std::string& _val370 = this->properties[_key369];
- xfer += iprot->readString(_val370);
+ std::string _key370;
+ xfer += iprot->readString(_key370);
+ std::string& _val371 = this->properties[_key370];
+ xfer += iprot->readString(_val371);
}
xfer += iprot->readMapEnd();
}
@@ -10188,11 +10212,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter371;
- for (_iter371 = this->properties.begin(); _iter371 != this->properties.end(); ++_iter371)
+ std::map<std::string, std::string> ::const_iterator _iter372;
+ for (_iter372 = this->properties.begin(); _iter372 != this->properties.end(); ++_iter372)
{
- xfer += oprot->writeString(_iter371->first);
- xfer += oprot->writeString(_iter371->second);
+ xfer += oprot->writeString(_iter372->first);
+ xfer += oprot->writeString(_iter372->second);
}
xfer += oprot->writeMapEnd();
}
@@ -10209,13 +10233,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) {
swap(a.__isset, b.__isset);
}
-EnvironmentContext::EnvironmentContext(const EnvironmentContext& other372) {
- properties = other372.properties;
- __isset = other372.__isset;
-}
-EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other373) {
+EnvironmentContext::EnvironmentContext(const EnvironmentContext& other373) {
properties = other373.properties;
__isset = other373.__isset;
+}
+EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other374) {
+ properties = other374.properties;
+ __isset = other374.__isset;
return *this;
}
void EnvironmentContext::printTo(std::ostream& out) const {
@@ -10337,17 +10361,17 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) {
swap(a.__isset, b.__isset);
}
-PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other374) {
- db_name = other374.db_name;
- tbl_name = other374.tbl_name;
- catName = other374.catName;
- __isset = other374.__isset;
-}
-PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other375) {
+PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other375) {
db_name = other375.db_name;
tbl_name = other375.tbl_name;
catName = other375.catName;
__isset = other375.__isset;
+}
+PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other376) {
+ db_name = other376.db_name;
+ tbl_name = other376.tbl_name;
+ catName = other376.catName;
+ __isset = other376.__isset;
return *this;
}
void PrimaryKeysRequest::printTo(std::ostream& out) const {
@@ -10394,14 +10418,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->primaryKeys.clear();
- uint32_t _size376;
- ::apache::thrift::protocol::TType _etype379;
- xfer += iprot->readListBegin(_etype379, _size376);
- this->primaryKeys.resize(_size376);
- uint32_t _i380;
- for (_i380 = 0; _i380 < _size376; ++_i380)
+ uint32_t _size377;
+ ::apache::thrift::protocol::TType _etype380;
+ xfer += iprot->readListBegin(_etype380, _size377);
+ this->primaryKeys.resize(_size377);
+ uint32_t _i381;
+ for (_i381 = 0; _i381 < _size377; ++_i381)
{
- xfer += this->primaryKeys[_i380].read(iprot);
+ xfer += this->primaryKeys[_i381].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10432,10 +10456,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter381;
- for (_iter381 = this->primaryKeys.begin(); _iter381 != this->primaryKeys.end(); ++_iter381)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter382;
+ for (_iter382 = this->primaryKeys.begin(); _iter382 != this->primaryKeys.end(); ++_iter382)
{
- xfer += (*_iter381).write(oprot);
+ xfer += (*_iter382).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10451,11 +10475,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) {
swap(a.primaryKeys, b.primaryKeys);
}
-PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other382) {
- primaryKeys = other382.primaryKeys;
-}
-PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other383) {
+PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other383) {
primaryKeys = other383.primaryKeys;
+}
+PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other384) {
+ primaryKeys = other384.primaryKeys;
return *this;
}
void PrimaryKeysResponse::printTo(std::ostream& out) const {
@@ -10605,21 +10629,21 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) {
swap(a.__isset, b.__isset);
}
-ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other384) {
- parent_db_name = other384.parent_db_name;
- parent_tbl_name = other384.parent_tbl_name;
- foreign_db_name = other384.foreign_db_name;
- foreign_tbl_name = other384.foreign_tbl_name;
- catName = other384.catName;
- __isset = other384.__isset;
-}
-ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other385) {
+ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other385) {
parent_db_name = other385.parent_db_name;
parent_tbl_name = other385.parent_tbl_name;
foreign_db_name = other385.foreign_db_name;
foreign_tbl_name = other385.foreign_tbl_name;
catName = other385.catName;
__isset = other385.__isset;
+}
+ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other386) {
+ parent_db_name = other386.parent_db_name;
+ parent_tbl_name = other386.parent_tbl_name;
+ foreign_db_name = other386.foreign_db_name;
+ foreign_tbl_name = other386.foreign_tbl_name;
+ catName = other386.catName;
+ __isset = other386.__isset;
return *this;
}
void ForeignKeysRequest::printTo(std::ostream& out) const {
@@ -10668,14 +10692,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->foreignKeys.clear();
- uint32_t _size386;
- ::apache::thrift::protocol::TType _etype389;
- xfer += iprot->readListBegin(_etype389, _size386);
- this->foreignKeys.resize(_size386);
- uint32_t _i390;
- for (_i390 = 0; _i390 < _size386; ++_i390)
+ uint32_t _size387;
+ ::apache::thrift::protocol::TType _etype390;
+ xfer += iprot->readListBegin(_etype390, _size387);
+ this->foreignKeys.resize(_size387);
+ uint32_t _i391;
+ for (_i391 = 0; _i391 < _size387; ++_i391)
{
- xfer += this->foreignKeys[_i390].read(iprot);
+ xfer += this->foreignKeys[_i391].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10706,10 +10730,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter391;
- for (_iter391 = this->foreignKeys.begin(); _iter391 != this->foreignKeys.end(); ++_iter391)
+ std::vector<SQLForeignKey> ::const_iterator _iter392;
+ for (_iter392 = this->foreignKeys.begin(); _iter392 != this->foreignKeys.end(); ++_iter392)
{
- xfer += (*_iter391).write(oprot);
+ xfer += (*_iter392).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10725,11 +10749,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) {
swap(a.foreignKeys, b.foreignKeys);
}
-ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other392) {
- foreignKeys = other392.foreignKeys;
-}
-ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other393) {
+ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other393) {
foreignKeys = other393.foreignKeys;
+}
+ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other394) {
+ foreignKeys = other394.foreignKeys;
return *this;
}
void ForeignKeysResponse::printTo(std::ostream& out) const {
@@ -10851,15 +10875,15 @@ void swap(UniqueConstraintsRequest &a, UniqueConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other394) {
- catName = other394.catName;
- db_name = other394.db_name;
- tbl_name = other394.tbl_name;
-}
-UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other395) {
+UniqueConstraintsRequest::UniqueConstraintsRequest(const UniqueConstraintsRequest& other395) {
catName = other395.catName;
db_name = other395.db_name;
tbl_name = other395.tbl_name;
+}
+UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const UniqueConstraintsRequest& other396) {
+ catName = other396.catName;
+ db_name = other396.db_name;
+ tbl_name = other396.tbl_name;
return *this;
}
void UniqueConstraintsRequest::printTo(std::ostream& out) const {
@@ -10906,14 +10930,14 @@ uint32_t UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->uniqueConstraints.clear();
- uint32_t _size396;
- ::apache::thrift::protocol::TType _etype399;
- xfer += iprot->readListBegin(_etype399, _size396);
- this->uniqueConstraints.resize(_size396);
- uint32_t _i400;
- for (_i400 = 0; _i400 < _size396; ++_i400)
+ uint32_t _size397;
+ ::apache::thrift::protocol::TType _etype400;
+ xfer += iprot->readListBegin(_etype400, _size397);
+ this->uniqueConstraints.resize(_size397);
+ uint32_t _i401;
+ for (_i401 = 0; _i401 < _size397; ++_i401)
{
- xfer += this->uniqueConstraints[_i400].read(iprot);
+ xfer += this->uniqueConstraints[_i401].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10944,10 +10968,10 @@ uint32_t UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size()));
- std::vector<SQLUniqueConstraint> ::const_iterator _iter401;
- for (_iter401 = this->uniqueConstraints.begin(); _iter401 != this->uniqueConstraints.end(); ++_iter401)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter402;
+ for (_iter402 = this->uniqueConstraints.begin(); _iter402 != this->uniqueConstraints.end(); ++_iter402)
{
- xfer += (*_iter401).write(oprot);
+ xfer += (*_iter402).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10963,11 +10987,11 @@ void swap(UniqueConstraintsResponse &a, UniqueConstraintsResponse &b) {
swap(a.uniqueConstraints, b.uniqueConstraints);
}
-UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other402) {
- uniqueConstraints = other402.uniqueConstraints;
-}
-UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other403) {
+UniqueConstraintsResponse::UniqueConstraintsResponse(const UniqueConstraintsResponse& other403) {
uniqueConstraints = other403.uniqueConstraints;
+}
+UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const UniqueConstraintsResponse& other404) {
+ uniqueConstraints = other404.uniqueConstraints;
return *this;
}
void UniqueConstraintsResponse::printTo(std::ostream& out) const {
@@ -11089,15 +11113,15 @@ void swap(NotNullConstraintsRequest &a, NotNullConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other404) {
- catName = other404.catName;
- db_name = other404.db_name;
- tbl_name = other404.tbl_name;
-}
-NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other405) {
+NotNullConstraintsRequest::NotNullConstraintsRequest(const NotNullConstraintsRequest& other405) {
catName = other405.catName;
db_name = other405.db_name;
tbl_name = other405.tbl_name;
+}
+NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const NotNullConstraintsRequest& other406) {
+ catName = other406.catName;
+ db_name = other406.db_name;
+ tbl_name = other406.tbl_name;
return *this;
}
void NotNullConstraintsRequest::printTo(std::ostream& out) const {
@@ -11144,14 +11168,14 @@ uint32_t NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->notNullConstraints.clear();
- uint32_t _size406;
- ::apache::thrift::protocol::TType _etype409;
- xfer += iprot->readListBegin(_etype409, _size406);
- this->notNullConstraints.resize(_size406);
- uint32_t _i410;
- for (_i410 = 0; _i410 < _size406; ++_i410)
+ uint32_t _size407;
+ ::apache::thrift::protocol::TType _etype410;
+ xfer += iprot->readListBegin(_etype410, _size407);
+ this->notNullConstraints.resize(_size407);
+ uint32_t _i411;
+ for (_i411 = 0; _i411 < _size407; ++_i411)
{
- xfer += this->notNullConstraints[_i410].read(iprot);
+ xfer += this->notNullConstraints[_i411].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11182,10 +11206,10 @@ uint32_t NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraints.size()));
- std::vector<SQLNotNullConstraint> ::const_iterator _iter411;
- for (_iter411 = this->notNullConstraints.begin(); _iter411 != this->notNullConstraints.end(); ++_iter411)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter412;
+ for (_iter412 = this->notNullConstraints.begin(); _iter412 != this->notNullConstraints.end(); ++_iter412)
{
- xfer += (*_iter411).write(oprot);
+ xfer += (*_iter412).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11201,11 +11225,11 @@ void swap(NotNullConstraintsResponse &a, NotNullConstraintsResponse &b) {
swap(a.notNullConstraints, b.notNullConstraints);
}
-NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other412) {
- notNullConstraints = other412.notNullConstraints;
-}
-NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other413) {
+NotNullConstraintsResponse::NotNullConstraintsResponse(const NotNullConstraintsResponse& other413) {
notNullConstraints = other413.notNullConstraints;
+}
+NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const NotNullConstraintsResponse& other414) {
+ notNullConstraints = other414.notNullConstraints;
return *this;
}
void NotNullConstraintsResponse::printTo(std::ostream& out) const {
@@ -11327,15 +11351,15 @@ void swap(DefaultConstraintsRequest &a, DefaultConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other414) {
- catName = other414.catName;
- db_name = other414.db_name;
- tbl_name = other414.tbl_name;
-}
-DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other415) {
+DefaultConstraintsRequest::DefaultConstraintsRequest(const DefaultConstraintsRequest& other415) {
catName = other415.catName;
db_name = other415.db_name;
tbl_name = other415.tbl_name;
+}
+DefaultConstraintsRequest& DefaultConstraintsRequest::operator=(const DefaultConstraintsRequest& other416) {
+ catName = other416.catName;
+ db_name = other416.db_name;
+ tbl_name = other416.tbl_name;
return *this;
}
void DefaultConstraintsRequest::printTo(std::ostream& out) const {
@@ -11382,14 +11406,14 @@ uint32_t DefaultConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->defaultConstraints.clear();
- uint32_t _size416;
- ::apache::thrift::protocol::TType _etype419;
- xfer += iprot->readListBegin(_etype419, _size416);
- this->defaultConstraints.resize(_size416);
- uint32_t _i420;
- for (_i420 = 0; _i420 < _size416; ++_i420)
+ uint32_t _size417;
+ ::apache::thrift::protocol::TType _etype420;
+ xfer += iprot->readListBegin(_etype420, _size417);
+ this->defaultConstraints.resize(_size417);
+ uint32_t _i421;
+ for (_i421 = 0; _i421 < _size417; ++_i421)
{
- xfer += this->defaultConstraints[_i420].read(iprot);
+ xfer += this->defaultConstraints[_i421].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11420,10 +11444,10 @@ uint32_t DefaultConstraintsResponse::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraints.size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter421;
- for (_iter421 = this->defaultConstraints.begin(); _iter421 != this->defaultConstraints.end(); ++_iter421)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter422;
+ for (_iter422 = this->defaultConstraints.begin(); _iter422 != this->defaultConstraints.end(); ++_iter422)
{
- xfer += (*_iter421).write(oprot);
+ xfer += (*_iter422).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11439,11 +11463,11 @@ void swap(DefaultConstraintsResponse &a, DefaultConstraintsResponse &b) {
swap(a.defaultConstraints, b.defaultConstraints);
}
-DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other422) {
- defaultConstraints = other422.defaultConstraints;
-}
-DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other423) {
+DefaultConstraintsResponse::DefaultConstraintsResponse(const DefaultConstraintsResponse& other423) {
defaultConstraints = other423.defaultConstraints;
+}
+DefaultConstraintsResponse& DefaultConstraintsResponse::operator=(const DefaultConstraintsResponse& other424) {
+ defaultConstraints = other424.defaultConstraints;
return *this;
}
void DefaultConstraintsResponse::printTo(std::ostream& out) const {
@@ -11565,15 +11589,15 @@ void swap(CheckConstraintsRequest &a, CheckConstraintsRequest &b) {
swap(a.tbl_name, b.tbl_name);
}
-CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other424) {
- catName = other424.catName;
- db_name = other424.db_name;
- tbl_name = other424.tbl_name;
-}
-CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other425) {
+CheckConstraintsRequest::CheckConstraintsRequest(const CheckConstraintsRequest& other425) {
catName = other425.catName;
db_name = other425.db_name;
tbl_name = other425.tbl_name;
+}
+CheckConstraintsRequest& CheckConstraintsRequest::operator=(const CheckConstraintsRequest& other426) {
+ catName = other426.catName;
+ db_name = other426.db_name;
+ tbl_name = other426.tbl_name;
return *this;
}
void CheckConstraintsRequest::printTo(std::ostream& out) const {
@@ -11620,14 +11644,14 @@ uint32_t CheckConstraintsResponse::read(::apache::thrift::protocol::TProtocol* i
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->checkConstraints.clear();
- uint32_t _size426;
- ::apache::thrift::protocol::TType _etype429;
- xfer += iprot->readListBegin(_etype429, _size426);
- this->checkConstraints.resize(_size426);
- uint32_t _i430;
- for (_i430 = 0; _i430 < _size426; ++_i430)
+ uint32_t _size427;
+ ::apache::thrift::protocol::TType _etype430;
+ xfer += iprot->readListBegin(_etype430, _size427);
+ this->checkConstraints.resize(_size427);
+ uint32_t _i431;
+ for (_i431 = 0; _i431 < _size427; ++_i431)
{
- xfer += this->checkConstraints[_i430].read(iprot);
+ xfer += this->checkConstraints[_i431].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11658,10 +11682,10 @@ uint32_t CheckConstraintsResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->checkConstraints.size()));
- std::vector<SQLCheckConstraint> ::const_iterator _iter431;
- for (_iter431 = this->checkConstraints.begin(); _iter431 != this->checkConstraints.end(); ++_iter431)
+ std::vector<SQLCheckConstraint> ::const_iterator _iter432;
+ for (_iter432 = this->checkConstraints.begin(); _iter432 != this->checkConstraints.end(); ++_iter432)
{
- xfer += (*_iter431).write(oprot);
+ xfer += (*_iter432).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11677,11 +11701,11 @@ void swap(CheckConstraintsResponse &a, CheckConstraintsResponse &b) {
swap(a.checkConstraints, b.checkConstraints);
}
-CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other432) {
- checkConstraints = other432.checkConstraints;
-}
-CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other433) {
+CheckConstraintsResponse::CheckConstraintsResponse(const CheckConstraintsResponse& other433) {
checkConstraints = other433.checkConstraints;
+}
+CheckConstraintsResponse& CheckConstraintsResponse::operator=(const CheckConstraintsResponse& other434) {
+ checkConstraints = other434.checkConstraints;
return *this;
}
void CheckConstraintsResponse::printTo(std::ostream& out) const {
@@ -11823,19 +11847,19 @@ void swap(DropConstraintRequest &a, DropConstraintRequest &b) {
swap(a.__isset, b.__isset);
}
-DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other434) {
- dbname = other434.dbname;
- tablename = other434.tablename;
- constraintname = other434.constraintname;
- catName = other434.catName;
- __isset = other434.__isset;
-}
-DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other435) {
+DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other435) {
dbname = other435.dbname;
tablename = other435.tablename;
constraintname = other435.constraintname;
catName = other435.catName;
__isset = other435.__isset;
+}
+DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other436) {
+ dbname = other436.dbname;
+ tablename = other436.tablename;
+ constraintname = other436.constraintname;
+ catName = other436.catName;
+ __isset = other436.__isset;
return *this;
}
void DropConstraintRequest::printTo(std::ostream& out) const {
@@ -11883,14 +11907,14 @@ uint32_t AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->primaryKeyCols.clear();
- uint32_t _size436;
- ::apache::thrift::protocol::TType _etype439;
- xfer += iprot->readListBegin(_etype439, _size436);
- this->primaryKeyCols.resize(_size436);
- uint32_t _i440;
- for (_i440 = 0; _i440 < _size436; ++_i440)
+ uint32_t _size437;
+ ::apache::thrift::protocol::TType _etype440;
+ xfer += iprot->readListBegin(_etype440, _size437);
+ this->primaryKeyCols.resize(_size437);
+ uint32_t _i441;
+ for (_i441 = 0; _i441 < _size437; ++_i441)
{
- xfer += this->primaryKeyCols[_i440].read(iprot);
+ xfer += this->primaryKeyCols[_i441].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11921,10 +11945,10 @@ uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeyCols.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter441;
- for (_iter441 = this->primaryKeyCols.begin(); _iter441 != this->primaryKeyCols.end(); ++_iter441)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter442;
+ for (_iter442 = this->primaryKeyCols.begin(); _iter442 != this->primaryKeyCols.end(); ++_iter442)
{
- xfer += (*_iter441).write(oprot);
+ xfer += (*_iter442).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11940,11 +11964,11 @@ void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) {
swap(a.primaryKeyCols, b.primaryKeyCols);
}
-AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other442) {
- primaryKeyCols = other442.primaryKeyCols;
-}
-AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other443) {
+AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other443) {
primaryKeyCols = other443.primaryKeyCols;
+}
+AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other444) {
+ primaryKeyCols = other444.primaryKeyCols;
return *this;
}
void AddPrimaryKeyRequest::printTo(std::ostream& out) const {
@@ -11989,14 +12013,14 @@ uint32_t AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->foreignKeyCols.clear();
- uint32_t _size444;
- ::apache::thrift::protocol::TType _etype447;
- xfer += iprot->readListBegin(_etype447, _size444);
- this->foreignKeyCols.resize(_size444);
- uint32_t _i448;
- for (_i448 = 0; _i448 < _size444; ++_i448)
+ uint32_t _size445;
+ ::apache::thrift::protocol::TType _etype448;
+ xfer += iprot->readListBegin(_etype448, _size445);
+ this->foreignKeyCols.resize(_size445);
+ uint32_t _i449;
+ for (_i449 = 0; _i449 < _size445; ++_i449)
{
- xfer += this->foreignKeyCols[_i448].read(iprot);
+ xfer += this->foreignKeyCols[_i449].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12027,10 +12051,10 @@ uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeyCols.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter449;
- for (_iter449 = this->foreignKeyCols.begin(); _iter449 != this->foreignKeyCols.end(); ++_iter449)
+ std::vector<SQLForeignKey> ::const_iterator _iter450;
+ for (_iter450 = this->foreignKeyCols.begin(); _iter450 != this->foreignKeyCols.end(); ++_iter450)
{
- xfer += (*_iter449).write(oprot);
+ xfer += (*_iter450).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12046,11 +12070,11 @@ void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) {
swap(a.foreignKeyCols, b.foreignKeyCols);
}
-AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other450) {
- foreignKeyCols = other450.foreignKeyCols;
-}
-AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other451) {
+AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other451) {
foreignKeyCols = other451.foreignKeyCols;
+}
+AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other452) {
+ foreignKeyCols = other452.foreignKeyCols;
return *this;
}
void AddForeignKeyRequest::printTo(std::ostream& out) const {
@@ -12095,14 +12119,14 @@ uint32_t AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->uniqueConstraintCols.clear();
- uint32_t _size452;
- ::apache::thrift::protocol::TType _etype455;
- xfer += iprot->readListBegin(_etype455, _size452);
- this->uniqueConstraintCols.resize(_size452);
- uint32_t _i456;
- for (_i456 = 0; _i456 < _size452; ++_i456)
+ uint32_t _size453;
+ ::apache::thrift::protocol::TType _etype456;
+ xfer += iprot->readListBegin(_etype456, _size453);
+ this->uniqueConstraintCols.resize(_size453);
+ uint32_t _i457;
+ for (_i457 = 0; _i457 < _size453; ++_i457)
{
- xfer += this->uniqueConstraintCols[_i456].read(iprot);
+ xfer += this->uniqueConstraintCols[_i457].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12133,10 +12157,10 @@ uint32_t AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol
xfer += oprot->writeFieldBegin("uniqueConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraintCols.size()));
- std::vector<SQLUniqueConstraint> ::const_iterator _iter457;
- for (_iter457 = this->uniqueConstraintCols.begin(); _iter457 != this->uniqueConstraintCols.end(); ++_iter457)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter458;
+ for (_iter458 = this->uniqueConstraintCols.begin(); _iter458 != this->uniqueConstraintCols.end(); ++_iter458)
{
- xfer += (*_iter457).write(oprot);
+ xfer += (*_iter458).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12152,11 +12176,11 @@ void swap(AddUniqueConstraintRequest &a, AddUniqueConstraintRequest &b) {
swap(a.uniqueConstraintCols, b.uniqueConstraintCols);
}
-AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other458) {
- uniqueConstraintCols = other458.uniqueConstraintCols;
-}
-AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other459) {
+AddUniqueConstraintRequest::AddUniqueConstraintRequest(const AddUniqueConstraintRequest& other459) {
uniqueConstraintCols = other459.uniqueConstraintCols;
+}
+AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const AddUniqueConstraintRequest& other460) {
+ uniqueConstraintCols = other460.uniqueConstraintCols;
return *this;
}
void AddUniqueConstraintRequest::printTo(std::ostream& out) const {
@@ -12201,14 +12225,14 @@ uint32_t AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->notNullConstraintCols.clear();
- uint32_t _size460;
- ::apache::thrift::protocol::TType _etype463;
- xfer += iprot->readListBegin(_etype463, _size460);
- this->notNullConstraintCols.resize(_size460);
- uint32_t _i464;
- for (_i464 = 0; _i464 < _size460; ++_i464)
+ uint32_t _size461;
+ ::apache::thrift::protocol::TType _etype464;
+ xfer += iprot->readListBegin(_etype464, _size461);
+ this->notNullConstraintCols.resize(_size461);
+ uint32_t _i465;
+ for (_i465 = 0; _i465 < _size461; ++_i465)
{
- xfer += this->notNullConstraintCols[_i464].read(iprot);
+ xfer += this->notNullConstraintCols[_i465].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12239,10 +12263,10 @@ uint32_t AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtoco
xfer += oprot->writeFieldBegin("notNullConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraintCols.size()));
- std::vector<SQLNotNullConstraint> ::const_iterator _iter465;
- for (_iter465 = this->notNullConstraintCols.begin(); _iter465 != this->notNullConstraintCols.end(); ++_iter465)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter466;
+ for (_iter466 = this->notNullConstraintCols.begin(); _iter466 != this->notNullConstraintCols.end(); ++_iter466)
{
- xfer += (*_iter465).write(oprot);
+ xfer += (*_iter466).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12258,11 +12282,11 @@ void swap(AddNotNullConstraintRequest &a, AddNotNullConstraintRequest &b) {
swap(a.notNullConstraintCols, b.notNullConstraintCols);
}
-AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other466) {
- notNullConstraintCols = other466.notNullConstraintCols;
-}
-AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other467) {
+AddNotNullConstraintRequest::AddNotNullConstraintRequest(const AddNotNullConstraintRequest& other467) {
notNullConstraintCols = other467.notNullConstraintCols;
+}
+AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const AddNotNullConstraintRequest& other468) {
+ notNullConstraintCols = other468.notNullConstraintCols;
return *this;
}
void AddNotNullConstraintRequest::printTo(std::ostream& out) const {
@@ -12307,14 +12331,14 @@ uint32_t AddDefaultConstraintRequest::read(::apache::thrift::protocol::TProtocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->defaultConstraintCols.clear();
- uint32_t _size468;
- ::apache::thrift::protocol::TType _etype471;
- xfer += iprot->readListBegin(_etype471, _size468);
- this->defaultConstraintCols.resize(_size468);
- uint32_t _i472;
- for (_i472 = 0; _i472 < _size468; ++_i472)
+ uint32_t _size469;
+ ::apache::thrift::protocol::TType _etype472;
+ xfer += iprot->readListBegin(_etype472, _size469);
+ this->defaultConstraintCols.resize(_size469);
+ uint32_t _i473;
+ for (_i473 = 0; _i473 < _size469; ++_i473)
{
- xfer += this->defaultConstraintCols[_i472].read(iprot);
+ xfer += this->defaultConstraintCols[_i473].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12345,10 +12369,10 @@ uint32_t AddDefaultConstraintRequest::write(::apache::thrift::protocol::TProtoco
xfer += oprot->writeFieldBegin("defaultConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraintCols.size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter473;
- for (_iter473 = this->defaultConstraintCols.begin(); _iter473 != this->defaultConstraintCols.end(); ++_iter473)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter474;
+ for (_iter474 = this->defaultConstraintCols.begin(); _iter474 != this->defaultConstraintCols.end(); ++_iter474)
{
- xfer += (*_iter473).write(oprot);
+ xfer += (*_iter474).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12364,11 +12388,11 @@ void swap(AddDefaultConstraintRequest &a, AddDefaultConstraintRequest &b) {
swap(a.defaultConstraintCols, b.defaultConstraintCols);
}
-AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other474) {
- defaultConstraintCols = other474.defaultConstraintCols;
-}
-AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other475) {
+AddDefaultConstraintRequest::AddDefaultConstraintRequest(const AddDefaultConstraintRequest& other475) {
defaultConstraintCols = other475.defaultConstraintCols;
+}
+AddDefaultConstraintRequest& AddDefaultConstraintRequest::operator=(const AddDefaultConstraintRequest& other476) {
+ defaultConstraintCols = other476.defaultConstraintCols;
return *this;
}
void AddDefaultConstraintRequest::printTo(std::ostream& out) const {
@@ -12413,14 +12437,14 @@ uint32_t AddCheckConstraintRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->checkConstraintCols.clear();
- uint32_t _size476;
- ::apache::thrift::protocol::TType _etype479;
- xfer += iprot->readListBegin(_etype479, _size476);
- this->checkConstraintCols.resize(_size476);
- uint32_t _i480;
- for (_i480 = 0; _i480 < _size476; ++_i480)
+ uint32_t _size477;
+ ::apache::thrift::protocol::TType _etype480;
+ xfer += iprot->readListBegin(_etype480, _size477);
+ this->checkConstraintCols.resize(_size477);
+ uint32_t _i481;
+ for (_i481 = 0; _i481 < _size477; ++_i481)
{
- xfer += this->checkConstraintCols[_i480].read(iprot);
+ xfer += this->checkConstraintCols[_i481].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12451,10 +12475,10 @@ uint32_t AddCheckConstraintRequest::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("checkConstraintCols", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->checkConstraintCols.size()));
- std::vector<SQLCheckConstraint> ::const_iterator _iter481;
- for (_iter481 = this->checkConstraintCols.begin(); _iter481 != this->checkConstraintCols.end(); ++_iter481)
+ std::vector<SQLCheckConstraint> ::const_iterator _iter482;
+ for (_iter482 = this->checkConstraintCols.begin(); _iter482 != this->checkConstraintCols.end(
<TRUNCATED>